﻿using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Drawing;

namespace Asol.Reporting.Green.Components.Commands
{
    #region IconLibrary
    /// <summary>
    /// Knihovna ikon
    /// </summary>
    internal class IconLibrary
    {
        #region Image ArrowAzureDown16
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku arrow-azure-down-16.png.
        /// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
        /// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
        /// Případně je možno vyvolat metodu ArrowAzureDown16_Reset(), která zajistí regenerování obrázku z jeho definice.
        /// Bezpečnější je používání property ArrowAzureDown16, která vrací vždy nový objekt.
        /// Pro používání pro Button.Image, kde bude nastavováno Button.Enabled = false; je třeba použít property ArrowAzureDown16_FromFile.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\DavidPrac\VSProjects\ReportEditor\Reporting.Green\Pics\source\arrow-azure-down-16.png
        /// </remarks>
        public static System.Drawing.Image ArrowAzureDown16_Cached
        {
            get
            {
                if (_ArrowAzureDown16 == null) _ArrowAzureDown16 = ArrowAzureDown16;
                return _ArrowAzureDown16;
            }
        }
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku arrow-azure-down-16.png.
        /// Nelze používat jako Image pro Buttony, kde bude nastavováno Enabled = false (pak dojde k chybě .NET: Ot of memory).
        /// Pak je třeba použít Image ArrowAzureDown16_FromFile.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití ArrowAzureDown16_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property ArrowAzureDown16_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\DavidPrac\VSProjects\ReportEditor\Reporting.Green\Pics\source\arrow-azure-down-16.png
        /// </remarks>
        public static System.Drawing.Image ArrowAzureDown16 { get { return _ImageCreateFrom(_ArrowAzureDown16_string, null); } }
        /// <summary>
        /// Vrátí obrázek, načtený ze souboru arrow-azure-down-16.png.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití ArrowAzureDown16_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property ArrowAzureDown16_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\DavidPrac\VSProjects\ReportEditor\Reporting.Green\Pics\source\arrow-azure-down-16.png
        /// </remarks>
        public static System.Drawing.Image ArrowAzureDown16_FromFile { get { return _ImageCreateFrom(_ArrowAzureDown16_string, "arrow-azure-down-16.png"); } }
        /// <summary>
        /// Vygeneruje a vrátí string, který definuje obsah souboru ArrowAzureDown16
        /// </summary>
        /// <returns></returns>
        private static string _ArrowAzureDown16_string()
        {
            System.Text.StringBuilder sb = new System.Text.StringBuilder(848);
            sb.Append("iVBORw0KGgoAAAANSUhEUgAAABAAAAAICAYAAADwdn+XAAAABGdBTUEAAK/INwWK6QAAAAlwSFlzAAAOwgAADsIBFShKgAAAAA10RVh0U291cmNlAE51dm9sYaxPNfEA");
            sb.Append("AAAadEVYdFNvZnR3YXJlAFBhaW50Lk5FVCB2My41LjExR/NCNwAAAd5JREFUKFNj+P//P4N66+TLPnNW/HScs+Kb3tRFr2V65qbIT1/GoLhoA4Pyym0MSsu3AentYWob");
            sb.Append("dr9Q27T3p8GOQ780t+y/BdILNkCvY8aDTbfv/b/5/f3/SXdu/bdYvO6v3OSlFTADlFdsy7TefvC78Y5D/x0OHP/vfez0f+2tB17ADZCsn2Bo3Lfw4oobt/8f//j6f9X1");
            sb.Append("6//NVm/7r7BwfZPaqu0VPruP/XXbfwKs2f3wyf86Ww/cVt24zxpugFTTRAapxqkqqpMWn5184dr/Ta+e/489ff6/9rqd/w037fvnAtRss/8Y2ACNLfuvqqzfq6+6aR9Y");
            sb.Append("L8SAhn4GmZ45DHJTlggozVp1oANoyKKnT//bAzUBFf632nv0v92+Y//VN+07BbRZFqRZZcNuhAFihQ1A3MIgO3E+g9LSzXwKCzauqzp39f+Uew/+ux468d98z5H/apv2");
            sb.Append("7VTbtl9MZcMeBqXF6xnkpy9BMiC3hoHPO5FBOLmMQbKmFxhwO9mVVu2en3v68v/ok+f/K6/ZvVp1yz5uhdnLGeQmLWCQ7pjGIDd1IbIBtQz8gekM/P6pDIIR2Qwy7VMZ");
            sb.Append("gM5kU9mwt15j0752oGZO+emLgWE1gUG6dTLQu7MZ5KcuAur9zwAABfcYHvZR7VUAAAAASUVORK5CYII=");
            return sb.ToString();
        }
        /// <summary>
        /// Resetuje obrázek v paměti.
        /// Následující použití property ArrowAzureDown16_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
        /// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
        /// </summary>
        public static void ArrowAzureDown16_Reset()
        {
            _ArrowAzureDown16 = null;
        }
        /// <summary>
        /// Úložiště objektu v paměti, při prvním použití ArrowAzureDown16_Direct je objekt naplněn a následně využíván.
        /// </summary>
        private static System.Drawing.Image _ArrowAzureDown16 = null;
        #endregion
        #region Image ArrowAzureDown24
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku arrow-azure-down-24.png.
        /// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
        /// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
        /// Případně je možno vyvolat metodu ArrowAzureDown24_Reset(), která zajistí regenerování obrázku z jeho definice.
        /// Bezpečnější je používání property ArrowAzureDown24, která vrací vždy nový objekt.
        /// Pro používání pro Button.Image, kde bude nastavováno Button.Enabled = false; je třeba použít property ArrowAzureDown24_FromFile.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\DavidPrac\VSProjects\ReportEditor\Reporting.Green\Pics\source\arrow-azure-down-24.png
        /// </remarks>
        public static System.Drawing.Image ArrowAzureDown24_Cached
        {
            get
            {
                if (_ArrowAzureDown24 == null) _ArrowAzureDown24 = ArrowAzureDown24;
                return _ArrowAzureDown24;
            }
        }
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku arrow-azure-down-24.png.
        /// Nelze používat jako Image pro Buttony, kde bude nastavováno Enabled = false (pak dojde k chybě .NET: Ot of memory).
        /// Pak je třeba použít Image ArrowAzureDown24_FromFile.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití ArrowAzureDown24_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property ArrowAzureDown24_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\DavidPrac\VSProjects\ReportEditor\Reporting.Green\Pics\source\arrow-azure-down-24.png
        /// </remarks>
        public static System.Drawing.Image ArrowAzureDown24 { get { return _ImageCreateFrom(_ArrowAzureDown24_string, null); } }
        /// <summary>
        /// Vrátí obrázek, načtený ze souboru arrow-azure-down-24.png.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití ArrowAzureDown24_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property ArrowAzureDown24_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\DavidPrac\VSProjects\ReportEditor\Reporting.Green\Pics\source\arrow-azure-down-24.png
        /// </remarks>
        public static System.Drawing.Image ArrowAzureDown24_FromFile { get { return _ImageCreateFrom(_ArrowAzureDown24_string, "arrow-azure-down-24.png"); } }
        /// <summary>
        /// Vygeneruje a vrátí string, který definuje obsah souboru ArrowAzureDown24
        /// </summary>
        /// <returns></returns>
        private static string _ArrowAzureDown24_string()
        {
            System.Text.StringBuilder sb = new System.Text.StringBuilder(1344);
            sb.Append("iVBORw0KGgoAAAANSUhEUgAAABgAAAAMCAYAAAB4MH11AAAABGdBTUEAAK/INwWK6QAAAAlwSFlzAAAOwgAADsIBFShKgAAAAA10RVh0U291cmNlAE51dm9sYaxPNfEA");
            sb.Append("AAAadEVYdFNvZnR3YXJlAFBhaW50Lk5FVCB2My41LjExR/NCNwAAA1NJREFUOE+NlGtIU3EYxt+lWZBGN9vU4+5rpWUX0qQslSS62eVLH+pDdC8oikoSMhuZmTlX3maa");
            sb.Append("t+myiZuXzeOc29nm5rw2IqkoK8UuJEVBEUVE/nuNI4su4AMP58vL7zn/57z/AxOiLishJB19UQWhl/Ig7EoRUNk3IVxVyk78LaneDNLGdpA120BmtPvcYmcnflN4jgpC");
            sb.Append("LigDQ9JyhSHp18WhGYXisCw1j7p2049fUA3Cch07CSBQV4JE3waS+lY/aYOFiwEyBMtkzXYRPmfK6H8E8M5lzxBfzkuJzq9wxBbXuKNvaTsXqzUG/o3yZEpZHiC45QuQ");
            sb.Append("1LWCqKbFX2JoWy9rsuoWGJm+RS2O3kja2SFvcaRjUBA76hP37NV5UcqSZgXTSQxDw6Ts2VOS2u8dW1PbNChUaw8ISmoDRVUGEN9pBXEtPV2ut+xaSTsHlpmdY8vaXCSx");
            sb.Append("o5vEO7oIhtikTQyXxfrES83xF2YWbttWqe+vGHj0w/3+Hal5/ZKcvnuPrK6nRyRV+jMYMAsDAiPqLYcTzK4nSUw3ibV1kiRXD0nq6BlbYXE9kJvsu/EEASzWJwwAXlqe");
            sb.Append("f1hW8YbESr3r+t2BH6bRUZI3PEz29XjJqqb2Uckd05VF+rb0jVbPi2RXH1lt7SSJzm6S4OweW2ru6Mf+d0obmWkYwFL/UKgiHyhlBQe9KlbTQCt6732re/WaKB4Pku3u");
            sb.Append("XrLcxHyNMjFf4q2eX3AEkzhH1/fFtNOO0Hi033/hE6KulQKVU8Xhq28via41as90eT9Xjrwgp+4/JHGMhyyhnWS5xUXWYd9Yz1fsvBGhMdj7lPEVnZT4+RoI2pkBwjK9");
            sb.Append("ZKmOLjri8X4qej5MDnkHSAx2vtbeRWLa3V8W0o5qhEeO7/2k4RMSlumAUmlApDFyIw3WjD0e79vcwSFy0HufrLS4P+A6qhDOF9dbJwePe6iD4ONpMHf/aZi9+zjM2XsS");
            sb.Append("eCmZIK5uBKnBNjfC5EjBDzu01dX3MoJ2KsZXUWZkQFCsxUqLgcothfAbFcAv0oCgRMtSf1PwsfMgOpEKAVG7OFPlmzhTF27mvPn+EYKPpuKNteAvgQlCb8G33oGeLW2w");
            sb.Append("QVhmAd5oM17SqxzuuWzO/JNZHLmuGUNvs1SAn9f3mMOizVeGAAAAAElFTkSuQmCC");
            return sb.ToString();
        }
        /// <summary>
        /// Resetuje obrázek v paměti.
        /// Následující použití property ArrowAzureDown24_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
        /// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
        /// </summary>
        public static void ArrowAzureDown24_Reset()
        {
            _ArrowAzureDown24 = null;
        }
        /// <summary>
        /// Úložiště objektu v paměti, při prvním použití ArrowAzureDown24_Direct je objekt naplněn a následně využíván.
        /// </summary>
        private static System.Drawing.Image _ArrowAzureDown24 = null;
        #endregion
        #region Image ArrowAzureDown32
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku arrow-azure-down-32.png.
        /// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
        /// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
        /// Případně je možno vyvolat metodu ArrowAzureDown32_Reset(), která zajistí regenerování obrázku z jeho definice.
        /// Bezpečnější je používání property ArrowAzureDown32, která vrací vždy nový objekt.
        /// Pro používání pro Button.Image, kde bude nastavováno Button.Enabled = false; je třeba použít property ArrowAzureDown32_FromFile.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\DavidPrac\VSProjects\ReportEditor\Reporting.Green\Pics\source\arrow-azure-down-32.png
        /// </remarks>
        public static System.Drawing.Image ArrowAzureDown32_Cached
        {
            get
            {
                if (_ArrowAzureDown32 == null) _ArrowAzureDown32 = ArrowAzureDown32;
                return _ArrowAzureDown32;
            }
        }
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku arrow-azure-down-32.png.
        /// Nelze používat jako Image pro Buttony, kde bude nastavováno Enabled = false (pak dojde k chybě .NET: Ot of memory).
        /// Pak je třeba použít Image ArrowAzureDown32_FromFile.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití ArrowAzureDown32_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property ArrowAzureDown32_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\DavidPrac\VSProjects\ReportEditor\Reporting.Green\Pics\source\arrow-azure-down-32.png
        /// </remarks>
        public static System.Drawing.Image ArrowAzureDown32 { get { return _ImageCreateFrom(_ArrowAzureDown32_string, null); } }
        /// <summary>
        /// Vrátí obrázek, načtený ze souboru arrow-azure-down-32.png.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití ArrowAzureDown32_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property ArrowAzureDown32_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\DavidPrac\VSProjects\ReportEditor\Reporting.Green\Pics\source\arrow-azure-down-32.png
        /// </remarks>
        public static System.Drawing.Image ArrowAzureDown32_FromFile { get { return _ImageCreateFrom(_ArrowAzureDown32_string, "arrow-azure-down-32.png"); } }
        /// <summary>
        /// Vygeneruje a vrátí string, který definuje obsah souboru ArrowAzureDown32
        /// </summary>
        /// <returns></returns>
        private static string _ArrowAzureDown32_string()
        {
            System.Text.StringBuilder sb = new System.Text.StringBuilder(1640);
            sb.Append("iVBORw0KGgoAAAANSUhEUgAAACAAAAAQCAYAAAB3AH1ZAAAABGdBTUEAAK/INwWK6QAAAAlwSFlzAAAOwgAADsIBFShKgAAAAA10RVh0U291cmNlAE51dm9sYaxPNfEA");
            sb.Append("AAAadEVYdFNvZnR3YXJlAFBhaW50Lk5FVCB2My41LjExR/NCNwAABC9JREFUSEvNlXtMW2UYxj8yAm4zLhkzSkvvh1IgG1OJeNmmMhgZLOrUJYt/LCM6r9FIMLhgkLlu");
            sb.Append("4MYdCsxSbgMGBVpaegXa05ZLWwaaOlG7QMCNycDBJHMab9nre7qziSEimpn4JE9Omnxff8/7vt93DvnfiZNbSMJziwjnaCnhHisnEfmVJOLkKcIrVhJ+eT27amVRGiuh");
            sb.Append("unpJpN5OIrvpP3lFhX9QyATYEJ5T+BgntySZc7QsiXNMkcT9qCqRV6QUrksrJILqJnb1ckk6LUTCwDVWDgbYiQH2IDQNnYLejt60YojwnIJQzpGiHNmJqunNJTULsWWq");
            sb.Append("hVhF/UKMouEKv1jVxyut2y5UNQYJVa3sjj9EIZxbrMcQ1jgM0UXpbfORRvqHKAN9XWZyLKJnEF6EXstuWS5s/QbOkWLnm1or2KcvgXpqChomJ6DivB+e1VlBpDjtF1Q1");
            sb.Append("7RMqzwSLGjXsLqy8w0IorSVI0m7ZKdP2jjxkcUK0gYY4iwu2OdyQ5h6BbfYhkHbToxhgI7ttubjy0mCOvOy1+JK62Y/P+sD//TVwXZ0Hzdw3oMAge012oJRtXwtr2l4W");
            sb.Append("N3aGis9gxTfhayRq83Ox2t6x3bQHEh0e2GrthyedHnjGOwq7XF7YbHIuIvx9dAiLWy4MQCJOVIZw5IqD0cW103Lc+NniIpi+nYPqixchb3wc9va6QNqoWRA1aN4Vt+jW");
            sb.Append("STrMIQhP36qzTe8fHIHdzuFA5Qz8ac9o4BltdMxH6ulMhN+NZml/Ie7xCiKorAuOKFC+IC1v9Gf0DYL7yjzo5+bg+MQEZJz7AvbYBiGq1fCduNWQh/DsBAM9e8jrg1QW");
            sb.Append("/gTT9qGz8Di2XWZ0XEDoITwPdzHwvw3AiFeiJDKjPohXWp8sqmz+JN3qukFjgM7ZWcj60g8HRnyQaBuAaE3Pr1Jtzy/JNjfssnluw1MRnoAhceZ+BD4faaLXrAq8VPyy");
            sb.Append("OhI3ZMZr1/KwqKbNts/ouNF9aQY0GOIN3+eQ0j8Mj/YOBKAxZidsMSMc250yOAzxPQMMfAShSVKzI+gfw29JcKqJcPNVRFjbHiWs12hSjY6fmyYvQPvly3AQu8CAYoyO");
            sb.Append("25Un9XuZw/cbAu3o+PX7mwm2nv23fynmzgtr1ETcoueLmvWqHQb6p+rxSVBjiBe9n8IWqwt20G54CqvHLjDwLnQMHrrVzXu1EjfpCNVhDpOorXmPmFzX8r8ah7aZGXjL");
            sb.Append("NxaoPtbk/BGB1Wg+A76jcEZ45YikzUjwDXcPpbVlP2juv5p9zg+Hx/zMCK5jxScRGvafwJeK0vcRqcURSunsr+D8z+MLZgqB7+Gs198R8H2ZH5J7Xz9MwtLfIRsPvI3P");
            sb.Append("DBL2UibZ9GoWuT9LHlgTqNJIh2DVD6AT8PfapXBunuLmV7SA+YrWEF5pLeFXNBBB1Wl2xS0R8jukm2X6IoQ7wAAAAABJRU5ErkJggg==");
            return sb.ToString();
        }
        /// <summary>
        /// Resetuje obrázek v paměti.
        /// Následující použití property ArrowAzureDown32_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
        /// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
        /// </summary>
        public static void ArrowAzureDown32_Reset()
        {
            _ArrowAzureDown32 = null;
        }
        /// <summary>
        /// Úložiště objektu v paměti, při prvním použití ArrowAzureDown32_Direct je objekt naplněn a následně využíván.
        /// </summary>
        private static System.Drawing.Image _ArrowAzureDown32 = null;
        #endregion
        #region Image ArrowAzureLeft16
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku arrow-azure-left-16.png.
        /// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
        /// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
        /// Případně je možno vyvolat metodu ArrowAzureLeft16_Reset(), která zajistí regenerování obrázku z jeho definice.
        /// Bezpečnější je používání property ArrowAzureLeft16, která vrací vždy nový objekt.
        /// Pro používání pro Button.Image, kde bude nastavováno Button.Enabled = false; je třeba použít property ArrowAzureLeft16_FromFile.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\DavidPrac\VSProjects\ReportEditor\Reporting.Green\Pics\source\arrow-azure-left-16.png
        /// </remarks>
        public static System.Drawing.Image ArrowAzureLeft16_Cached
        {
            get
            {
                if (_ArrowAzureLeft16 == null) _ArrowAzureLeft16 = ArrowAzureLeft16;
                return _ArrowAzureLeft16;
            }
        }
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku arrow-azure-left-16.png.
        /// Nelze používat jako Image pro Buttony, kde bude nastavováno Enabled = false (pak dojde k chybě .NET: Ot of memory).
        /// Pak je třeba použít Image ArrowAzureLeft16_FromFile.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití ArrowAzureLeft16_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property ArrowAzureLeft16_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\DavidPrac\VSProjects\ReportEditor\Reporting.Green\Pics\source\arrow-azure-left-16.png
        /// </remarks>
        public static System.Drawing.Image ArrowAzureLeft16 { get { return _ImageCreateFrom(_ArrowAzureLeft16_string, null); } }
        /// <summary>
        /// Vrátí obrázek, načtený ze souboru arrow-azure-left-16.png.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití ArrowAzureLeft16_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property ArrowAzureLeft16_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\DavidPrac\VSProjects\ReportEditor\Reporting.Green\Pics\source\arrow-azure-left-16.png
        /// </remarks>
        public static System.Drawing.Image ArrowAzureLeft16_FromFile { get { return _ImageCreateFrom(_ArrowAzureLeft16_string, "arrow-azure-left-16.png"); } }
        /// <summary>
        /// Vygeneruje a vrátí string, který definuje obsah souboru ArrowAzureLeft16
        /// </summary>
        /// <returns></returns>
        private static string _ArrowAzureLeft16_string()
        {
            System.Text.StringBuilder sb = new System.Text.StringBuilder(836);
            sb.Append("iVBORw0KGgoAAAANSUhEUgAAAAgAAAAQCAYAAAArij59AAAABGdBTUEAAK/INwWK6QAAAAlwSFlzAAAOwgAADsIBFShKgAAAAA10RVh0U291cmNlAE51dm9sYaxPNfEA");
            sb.Append("AAAadEVYdFNvZnR3YXJlAFBhaW50Lk5FVCB2My41LjExR/NCNwAAAdVJREFUKFNj+P//P17MIJJeiYozqhgkcuryNQrr/4vHF1QziCSXMggnlQAxkE4oYRAIy8+In7rg");
            sb.Append("/7zTp/7LpZQdYBCKz2cQjM5jEIzMY+APyYlxrOv5ffPDs/8Lr13+L5Favg+ooIBBKCafQSA0x9uirPXj3kd3/u99/+R/2sat/0XTKhaAFfAHZ5npZ9U823Tryv+Fz+//");
            sb.Append("T9qx979Mdu1VkfQKeQbBiBxNlcTSm0sunv3f++DWf8/NO//L5dY/FEkt15EobWVgkE8tvTD91Mn/1bev/zdYvfW/RGHDM6BPDEWzqhgkq7sZGNRzqm5kHDz032Tfkf9q");
            sb.Append("yzb+Vy5veyhe0qom1TyRQapxAgODUHSuiURm9UPbTTv+Wxw8+j9g057/uo0TbknW9qrIdE5jYBBOLASGRYmzYk3XW8ed+/7bHTr+32Pjrv+q7VNPyvTMlAQqKACGYDmD");
            sb.Append("WH59pGrH1O+uew/9tz5w7L/m4nX/ZXpmzQCGQQ6DcHIxg1heHYN4WVuaNjAU/Y6f+m+0dc9/uYnz9zFIVLQBXdvJINXQxwBymHTL5FKTJWv/u+w68F9pxrIDDLJ9syC4");
            sb.Append("ZyYQz2CQ6Z7OID9xXo36/FX/leatbMEaxQj8nwEAgUD7sZni1FUAAAAASUVORK5CYII=");
            return sb.ToString();
        }
        /// <summary>
        /// Resetuje obrázek v paměti.
        /// Následující použití property ArrowAzureLeft16_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
        /// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
        /// </summary>
        public static void ArrowAzureLeft16_Reset()
        {
            _ArrowAzureLeft16 = null;
        }
        /// <summary>
        /// Úložiště objektu v paměti, při prvním použití ArrowAzureLeft16_Direct je objekt naplněn a následně využíván.
        /// </summary>
        private static System.Drawing.Image _ArrowAzureLeft16 = null;
        #endregion
        #region Image ArrowAzureLeft24
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku arrow-azure-left-24.png.
        /// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
        /// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
        /// Případně je možno vyvolat metodu ArrowAzureLeft24_Reset(), která zajistí regenerování obrázku z jeho definice.
        /// Bezpečnější je používání property ArrowAzureLeft24, která vrací vždy nový objekt.
        /// Pro používání pro Button.Image, kde bude nastavováno Button.Enabled = false; je třeba použít property ArrowAzureLeft24_FromFile.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\DavidPrac\VSProjects\ReportEditor\Reporting.Green\Pics\source\arrow-azure-left-24.png
        /// </remarks>
        public static System.Drawing.Image ArrowAzureLeft24_Cached
        {
            get
            {
                if (_ArrowAzureLeft24 == null) _ArrowAzureLeft24 = ArrowAzureLeft24;
                return _ArrowAzureLeft24;
            }
        }
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku arrow-azure-left-24.png.
        /// Nelze používat jako Image pro Buttony, kde bude nastavováno Enabled = false (pak dojde k chybě .NET: Ot of memory).
        /// Pak je třeba použít Image ArrowAzureLeft24_FromFile.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití ArrowAzureLeft24_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property ArrowAzureLeft24_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\DavidPrac\VSProjects\ReportEditor\Reporting.Green\Pics\source\arrow-azure-left-24.png
        /// </remarks>
        public static System.Drawing.Image ArrowAzureLeft24 { get { return _ImageCreateFrom(_ArrowAzureLeft24_string, null); } }
        /// <summary>
        /// Vrátí obrázek, načtený ze souboru arrow-azure-left-24.png.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití ArrowAzureLeft24_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property ArrowAzureLeft24_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\DavidPrac\VSProjects\ReportEditor\Reporting.Green\Pics\source\arrow-azure-left-24.png
        /// </remarks>
        public static System.Drawing.Image ArrowAzureLeft24_FromFile { get { return _ImageCreateFrom(_ArrowAzureLeft24_string, "arrow-azure-left-24.png"); } }
        /// <summary>
        /// Vygeneruje a vrátí string, který definuje obsah souboru ArrowAzureLeft24
        /// </summary>
        /// <returns></returns>
        private static string _ArrowAzureLeft24_string()
        {
            System.Text.StringBuilder sb = new System.Text.StringBuilder(1244);
            sb.Append("iVBORw0KGgoAAAANSUhEUgAAAAwAAAAYCAYAAADOMhxqAAAABGdBTUEAAK/INwWK6QAAAAlwSFlzAAAOwgAADsIBFShKgAAAAA10RVh0U291cmNlAE51dm9sYaxPNfEA");
            sb.Append("AAAadEVYdFNvZnR3YXJlAFBhaW50Lk5FVCB2My41LjExR/NCNwAAAwZJREFUOE9joDoQL2xkEM2oYBBOKmIQjs+DiuIAEhXdDMLeyQxCcSU8gpF5wkJxucxQKexAOLGY");
            sb.Append("QSS9UlKpoL5LJa9mpWhigQVUChWIFdQzCMXmMwinlIko59e1Zy9Z9Slm1oLv4slFuVAlqEAgPAeooYhPOqOiMmnukjd7Ht39n79+00+xtNJiqBIEEEkuYRCMLuCQSCnN");
            sb.Append("Dpk8+9nme7f/73v74n/qmg0/xTMrUDUIRuSA3M0uFlcY6d015c6SK5f+b3z55P+0Wzf/e02f/0YssyoGqhSoODIXqLiMCeh2L7u67guzzp39v/TZ4/+t16//D1q06odS");
            sb.Append("afMckcwqabBi4eQiBsGYAkagDXamFa1He44c+Tfn8YP/Becv/fdasuaPQlnLGmBoaVhfWQFWD9LAKBiVa6hb1LC7bufuP5Pv3fkfe+Lsf4fFa34rVrbvEc2sMhIvamQU");
            sb.Append("za2FaBCMzBFSyKyYmb9u4+/+2zf/+xw7/d94+cb/8tWd54CK7cVyaxjFixogikFAMDJbRDmnemHy+s1/g4+d+q+74+B/zUVr/yvWdp+SLGy0YLfIYJBqmgRVDQRC0blM");
            sb.Append("IomFlorlLUdMF63+a7n78H/jbfv/uy5Z/0u/bfJGiYoOzf///zPIdE6HawBGVAGTSHq5u2JDzznL1Zv+W+87+t9p5+H/7ss3/FTvmDpfqqFfQaZ7NkQDCAgnFDKI5lSz");
            sb.Append("AN0aqto++abdpp1gTQ5A26wWrfmq2DNzgnTHdDGocggAJWPxkmYuqcr2VK1Jc584btv73/bAsf+mW/b+V5m17IVM76wIqFIEEC9tZpCo7OCRaeov15+19LXbnkNgm9SX");
            sb.Append("rP8pN2k+ZloCAYnyNgagm4Xku2a0mixZ+9Fj/5H/hqu2/JSfugi7BsmaLgbJ+l5gqMyQUpo8f4r5mi1fjVdt+aE4cxn+LCfVPIlBbuJ8BeWZS6epzl+1WXHuCjuoFHYg");
            sb.Append("2zeLQTKxkkFu6mJ+uWlLxRTmrmKFSuEGclMXMshPX8ygOGs5g8LclVBRogEDAwBcIzu6JmMqwgAAAABJRU5ErkJggg==");
            return sb.ToString();
        }
        /// <summary>
        /// Resetuje obrázek v paměti.
        /// Následující použití property ArrowAzureLeft24_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
        /// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
        /// </summary>
        public static void ArrowAzureLeft24_Reset()
        {
            _ArrowAzureLeft24 = null;
        }
        /// <summary>
        /// Úložiště objektu v paměti, při prvním použití ArrowAzureLeft24_Direct je objekt naplněn a následně využíván.
        /// </summary>
        private static System.Drawing.Image _ArrowAzureLeft24 = null;
        #endregion
        #region Image ArrowAzureLeft32
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku arrow-azure-left-32.png.
        /// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
        /// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
        /// Případně je možno vyvolat metodu ArrowAzureLeft32_Reset(), která zajistí regenerování obrázku z jeho definice.
        /// Bezpečnější je používání property ArrowAzureLeft32, která vrací vždy nový objekt.
        /// Pro používání pro Button.Image, kde bude nastavováno Button.Enabled = false; je třeba použít property ArrowAzureLeft32_FromFile.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\DavidPrac\VSProjects\ReportEditor\Reporting.Green\Pics\source\arrow-azure-left-32.png
        /// </remarks>
        public static System.Drawing.Image ArrowAzureLeft32_Cached
        {
            get
            {
                if (_ArrowAzureLeft32 == null) _ArrowAzureLeft32 = ArrowAzureLeft32;
                return _ArrowAzureLeft32;
            }
        }
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku arrow-azure-left-32.png.
        /// Nelze používat jako Image pro Buttony, kde bude nastavováno Enabled = false (pak dojde k chybě .NET: Ot of memory).
        /// Pak je třeba použít Image ArrowAzureLeft32_FromFile.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití ArrowAzureLeft32_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property ArrowAzureLeft32_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\DavidPrac\VSProjects\ReportEditor\Reporting.Green\Pics\source\arrow-azure-left-32.png
        /// </remarks>
        public static System.Drawing.Image ArrowAzureLeft32 { get { return _ImageCreateFrom(_ArrowAzureLeft32_string, null); } }
        /// <summary>
        /// Vrátí obrázek, načtený ze souboru arrow-azure-left-32.png.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití ArrowAzureLeft32_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property ArrowAzureLeft32_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\DavidPrac\VSProjects\ReportEditor\Reporting.Green\Pics\source\arrow-azure-left-32.png
        /// </remarks>
        public static System.Drawing.Image ArrowAzureLeft32_FromFile { get { return _ImageCreateFrom(_ArrowAzureLeft32_string, "arrow-azure-left-32.png"); } }
        /// <summary>
        /// Vygeneruje a vrátí string, který definuje obsah souboru ArrowAzureLeft32
        /// </summary>
        /// <returns></returns>
        private static string _ArrowAzureLeft32_string()
        {
            System.Text.StringBuilder sb = new System.Text.StringBuilder(1692);
            sb.Append("iVBORw0KGgoAAAANSUhEUgAAABAAAAAgCAYAAAAbifjMAAAABGdBTUEAAK/INwWK6QAAAAlwSFlzAAAOwgAADsIBFShKgAAAAA10RVh0U291cmNlAE51dm9sYaxPNfEA");
            sb.Append("AAAadEVYdFNvZnR3YXJlAFBhaW50Lk5FVCB2My41LjExR/NCNwAABFZJREFUSEvVlHtMU1ccxw86cGqWjfa2lNIXjCEZ29S5mGxBYzVBZcO4JTNLHBLAAhuv0ncpSLsC");
            sb.Append("1YJQSnm0FAhvRQuOxxAoTx1smm1kbMhjJEiGgGzKuix7+9sp3GwIQ/lv2Se5/9zf7/M959xzzkX/PzyS0hARI0fU8CRECY0j324QD4kWeSozN9PeVz5NjRS5UcOFZGUD");
            sb.Append("0BNSESNZ50qLVQmI05JualhiGjUswZ0sPxpPVSZiqvWbCIH83QCJdjaitAq8Y5VzlFOJB8iW9aHHqRDXVOxCRCuOc99Lvn3e3g32qQnwl6gdlDDhMbLt3+EaC5F3SRki");
            sb.Append("BLKDXtHyEYXtQxhxzEPD5Bj4STUOarg4hGxdCz1ehba9dgIRUbI99EjxzajyGhi6NwvXF+egcmIMdsi1Dhy8fgCenlP2JcJFV0/kl/x5ffY22O/NgW1+BkxfDYOvLH2R");
            sb.Append("FqMMJtsfhhohwrKURT0lrA/WGR90TX8DV7+7A8XTU5A/MQ5vmCuBEZfSQ49PeZZU/oEQSPBBkblTQhPN+1L1vzRN3IJWLOsmJyFjfBxCymqBGZ86QYtL4TPkWhdSW4Ya");
            sb.Append("kYSIaOlTlJMJ2l0Szc+VQ5/hkWcgeXQMkoaGIaTmMjCFadO0ONU7rPRsFw+xhjQxhECMt0yxhXIyXrYjXvWDaXAQPlqYAeHwCITe+AIO1zUCS6S5j+VoLLo6j/RDEFES");
            sb.Append("NyxH8GLk32s77dC28C1E41EP9w7C/rorwJJqF7EsZ0g+eNJDpCatFVBCE17yDBd9Lb3SDK3z0xA59CW80n4N9ja2Ayf57G/0WNU5POp2euIZ0lgFHn2PV5R0UtXVDcrR");
            sb.Append("UdjV3g8Brb3wQn0LMBWZv9KFaWcYyswtnil60lgFvllb8RUV+4jUPwbWNsD+3oGlkOebuoBf0wgBaefvekjSBUxN1hNeWgNprQDfLuf2bSciJTqWLP2nQFsLHMDr39nW");
            sb.Append("B0FdAxDW2AbPqXPvMFT6t70yDJtY+gLSXAFxWoxoscnu+DF5q7N/5ze1A79vOeRo9wC8dakZfLR5I0x1btAzggrSWgWWEf7KTPxc8jtr+iOoo/fvmRztGYRD1Tbg6kyf");
            sb.Append("s3QFL7NzraS1CnxEEUOe4e8py+wMMJbCkZ5rSyG7O/qB39kPL1rrHrD0xc3snBI2qawFbxv+kZzbzUzN+mSnpRpe7x9YWo4zxN/WBhxj2X22wXqEbF8LQ5GJeJYK/CfK");
            sb.Append("4bPS827trbLBsY8/Xf4mzXbgFlY6OMby9a+zE6YmB7Gzi1y8MvLf5OqLpwIvt8DxwZuwr6MPvM3VDk5BxaMDnDj3nG2wbMZrjvAxlt892GqH4L4B8LVecHCLqh8f4ISV");
            sb.Append("VYQ4eaVubENpop+59v6rDW3gW16/wCupO0S2PB52jgXhKW/jFlYpeObaGzzrBQOvrJ5OljcGDkA8a50r11JL4VkvbuVaasjKBuHklSGuuQbhAMQrvYjwDMjKfwdCfwEm");
            sb.Append("I/+ovrY39QAAAABJRU5ErkJggg==");
            return sb.ToString();
        }
        /// <summary>
        /// Resetuje obrázek v paměti.
        /// Následující použití property ArrowAzureLeft32_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
        /// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
        /// </summary>
        public static void ArrowAzureLeft32_Reset()
        {
            _ArrowAzureLeft32 = null;
        }
        /// <summary>
        /// Úložiště objektu v paměti, při prvním použití ArrowAzureLeft32_Direct je objekt naplněn a následně využíván.
        /// </summary>
        private static System.Drawing.Image _ArrowAzureLeft32 = null;
        #endregion
        #region Image ArrowAzureRight16
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku arrow-azure-right-16.png.
        /// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
        /// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
        /// Případně je možno vyvolat metodu ArrowAzureRight16_Reset(), která zajistí regenerování obrázku z jeho definice.
        /// Bezpečnější je používání property ArrowAzureRight16, která vrací vždy nový objekt.
        /// Pro používání pro Button.Image, kde bude nastavováno Button.Enabled = false; je třeba použít property ArrowAzureRight16_FromFile.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\DavidPrac\VSProjects\ReportEditor\Reporting.Green\Pics\source\arrow-azure-right-16.png
        /// </remarks>
        public static System.Drawing.Image ArrowAzureRight16_Cached
        {
            get
            {
                if (_ArrowAzureRight16 == null) _ArrowAzureRight16 = ArrowAzureRight16;
                return _ArrowAzureRight16;
            }
        }
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku arrow-azure-right-16.png.
        /// Nelze používat jako Image pro Buttony, kde bude nastavováno Enabled = false (pak dojde k chybě .NET: Ot of memory).
        /// Pak je třeba použít Image ArrowAzureRight16_FromFile.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití ArrowAzureRight16_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property ArrowAzureRight16_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\DavidPrac\VSProjects\ReportEditor\Reporting.Green\Pics\source\arrow-azure-right-16.png
        /// </remarks>
        public static System.Drawing.Image ArrowAzureRight16 { get { return _ImageCreateFrom(_ArrowAzureRight16_string, null); } }
        /// <summary>
        /// Vrátí obrázek, načtený ze souboru arrow-azure-right-16.png.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití ArrowAzureRight16_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property ArrowAzureRight16_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\DavidPrac\VSProjects\ReportEditor\Reporting.Green\Pics\source\arrow-azure-right-16.png
        /// </remarks>
        public static System.Drawing.Image ArrowAzureRight16_FromFile { get { return _ImageCreateFrom(_ArrowAzureRight16_string, "arrow-azure-right-16.png"); } }
        /// <summary>
        /// Vygeneruje a vrátí string, který definuje obsah souboru ArrowAzureRight16
        /// </summary>
        /// <returns></returns>
        private static string _ArrowAzureRight16_string()
        {
            System.Text.StringBuilder sb = new System.Text.StringBuilder(860);
            sb.Append("iVBORw0KGgoAAAANSUhEUgAAAAgAAAAQCAYAAAArij59AAAABGdBTUEAAK/INwWK6QAAAAlwSFlzAAAOwgAADsIBFShKgAAAAA10RVh0U291cmNlAE51dm9sYaxPNfEA");
            sb.Append("AAAadEVYdFNvZnR3YXJlAFBhaW50Lk5FVCB2My41LjExR/NCNwAAAeZJREFUKFNj+P//P17MoFLeelmrouOBaE6DoXhZO4NUwwQG8ZIWBqG4XAbhxEIGBq/+OT83Xr3x");
            sb.Append("X7+q96JYUauKVEM/g2RND4NgZB4Dv38qA4Nd36xvN7+/+7/8wpX/CpXdZ4GSAjI9sxhE0qsZ+HySGBi0GvtfT7p+5f+Jj6/+Tzhy6r90de8BqebJfLJ9c4BWFDEwiBW1");
            sb.Append("pBj3z/5bdfXq/82vnv9vPXDsv0RN/zqZnjnsEmUtDAzipa0MYoUtFUbTF/+POX3u/+KnT/6X7jjwX7Jhynz56UvZGMTL2oC4nUGisrtJbfqS/w4Hjv+f8uDB/4xt+/7L");
            sb.Append("9M6tZ5Bum8Ig1TSJQbZpYoX2rGX/VLfu++965OT/8O37/itOWtAOViDdODHTbcGavy57j/23Onjsv8mqzf9luuaslp++hJNBumVymOmsZd9d9x79bwuUtNqw/b/chHk7");
            sb.Append("5aYs4pZq6mdgkOud9dxw0+7/jkdO/Lfbsue/wqQFp+SmLBQDYmCINjMwyE9d+A0k6bbrwH/FKQuvyk1aICs/YykwyPsYxPLrgAE1d8VPz32H/6tOX3JbdsJ8fZBO2f45");
            sb.Append("DBIVHQziRU0MDMrTFt1Wnbn0hezE+dZA3QxAuxlkuqYDvd0GjJNOBqxRjMD/GQBFwga4h65B/AAAAABJRU5ErkJggg==");
            return sb.ToString();
        }
        /// <summary>
        /// Resetuje obrázek v paměti.
        /// Následující použití property ArrowAzureRight16_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
        /// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
        /// </summary>
        public static void ArrowAzureRight16_Reset()
        {
            _ArrowAzureRight16 = null;
        }
        /// <summary>
        /// Úložiště objektu v paměti, při prvním použití ArrowAzureRight16_Direct je objekt naplněn a následně využíván.
        /// </summary>
        private static System.Drawing.Image _ArrowAzureRight16 = null;
        #endregion
        #region Image ArrowAzureRight24
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku arrow-azure-right-24.png.
        /// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
        /// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
        /// Případně je možno vyvolat metodu ArrowAzureRight24_Reset(), která zajistí regenerování obrázku z jeho definice.
        /// Bezpečnější je používání property ArrowAzureRight24, která vrací vždy nový objekt.
        /// Pro používání pro Button.Image, kde bude nastavováno Button.Enabled = false; je třeba použít property ArrowAzureRight24_FromFile.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\DavidPrac\VSProjects\ReportEditor\Reporting.Green\Pics\source\arrow-azure-right-24.png
        /// </remarks>
        public static System.Drawing.Image ArrowAzureRight24_Cached
        {
            get
            {
                if (_ArrowAzureRight24 == null) _ArrowAzureRight24 = ArrowAzureRight24;
                return _ArrowAzureRight24;
            }
        }
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku arrow-azure-right-24.png.
        /// Nelze používat jako Image pro Buttony, kde bude nastavováno Enabled = false (pak dojde k chybě .NET: Ot of memory).
        /// Pak je třeba použít Image ArrowAzureRight24_FromFile.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití ArrowAzureRight24_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property ArrowAzureRight24_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\DavidPrac\VSProjects\ReportEditor\Reporting.Green\Pics\source\arrow-azure-right-24.png
        /// </remarks>
        public static System.Drawing.Image ArrowAzureRight24 { get { return _ImageCreateFrom(_ArrowAzureRight24_string, null); } }
        /// <summary>
        /// Vrátí obrázek, načtený ze souboru arrow-azure-right-24.png.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití ArrowAzureRight24_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property ArrowAzureRight24_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\DavidPrac\VSProjects\ReportEditor\Reporting.Green\Pics\source\arrow-azure-right-24.png
        /// </remarks>
        public static System.Drawing.Image ArrowAzureRight24_FromFile { get { return _ImageCreateFrom(_ArrowAzureRight24_string, "arrow-azure-right-24.png"); } }
        /// <summary>
        /// Vygeneruje a vrátí string, který definuje obsah souboru ArrowAzureRight24
        /// </summary>
        /// <returns></returns>
        private static string _ArrowAzureRight24_string()
        {
            System.Text.StringBuilder sb = new System.Text.StringBuilder(1308);
            sb.Append("iVBORw0KGgoAAAANSUhEUgAAAAwAAAAYCAYAAADOMhxqAAAABGdBTUEAAK/INwWK6QAAAAlwSFlzAAAOwgAADsIBFShKgAAAAA10RVh0U291cmNlAE51dm9sYaxPNfEA");
            sb.Append("AAAadEVYdFNvZnR3YXJlAFBhaW50Lk5FVCB2My41LjExR/NCNwAAAzdJREFUOE+tkm1IU1EYx485g97L5e6ad3c6LbQy6U1LM7EIokKqDxFBIIpUFKbWorLN5eZsL81t");
            sb.Append("bXNT517UXLUYpmI1TdtWGRXRey0qkoioCPpgRKBPZ/fewiL6EP3gwMM5v/9znnu46J8gKqrpxSvHq0LO7v4FgUyFEvZUTeEWH57NLT3CSdhbzZ78CkeUwxS8MtlUkUQp");
            sb.Append("WSDVdpIHlYXc0ioOcUDJHI4jlpjPFAl7pUlLa40D1V0B2GBsucWrVKzj7a+ZwD+qYQSWuPRNMXTB2ycTL1ObQ77Ic3DcvDu6SmcPEpW12XxJbYxAYaSdKHFpG9hAmVy8");
            sb.Append("WGMONz97CqGPH0AXHBpdom7o4R/RZqQ6bbQT5WeAqKzhpykM5w9dDY+1vhmGrrdvQRoIfs3U2tv4x06mkHVWRKptOLCR9hFxSMkRHD5RmG10RMrDQ2B89Qq8r4ehoqd/");
            sb.Append("JE1ts/ClBiKxbnzgoBLhV5koqNKWLLe6XxddvQ7ypxFwvHgJxf6Ln1M1dkWiysoldU1MIO9aCSIktYhfpZlG1hgOLG1sf1fYH4bye4/A/CQC23w971P0DgkOTGcSLHOk");
            sb.Append("OiSQ188kVWbVQueZL7mBIJTeuQ/aB49hfUfnS6Hewc7EIlCYkeC4aWqyxiab3+wdWdh9BbL6wlAydBvWn+t+Qxmcm1kVoUQVluWmSWKtfVeByze8GsuLLwVhFb4ls93/");
            sb.Append("KcXqkVNG5yxaJusseH49J0ndsC235eyzjb2DkBMIQ15fCJacuTCSbPHocXcCB2g/GogVnrCuXWRru7emuw9y+q9BPv7oLF/PV7G11YNlIalvQvE7drMBtZWg6pu8Gd4L");
            sb.Append("oysCISgYuA4r/b3f5trb/bjrgoKIA1EW97iAtkEsOuUMZ3YGYO3gDcjrujw2r/H0AGVyZYkaO2KSXR20xy0qY34NUmcXpzS0hvIvD8Ka3itj6Q7vLdw5n7K0xlBmN+1E");
            sb.Append("id+5nwkI65uT5trbBnP9vZDh8T3E12+mTG4OXvT5D2Zs2cUGDI7pyRa3DM8cSLJ4dmBx4u9ylEnZW5lCZHEhPMI0YfTpTO64P8lRJq/ezhSUqQVRp1xIZPXQr/EfQeg7");
            sb.Append("+QlbkwLfv7IAAAAASUVORK5CYII=");
            return sb.ToString();
        }
        /// <summary>
        /// Resetuje obrázek v paměti.
        /// Následující použití property ArrowAzureRight24_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
        /// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
        /// </summary>
        public static void ArrowAzureRight24_Reset()
        {
            _ArrowAzureRight24 = null;
        }
        /// <summary>
        /// Úložiště objektu v paměti, při prvním použití ArrowAzureRight24_Direct je objekt naplněn a následně využíván.
        /// </summary>
        private static System.Drawing.Image _ArrowAzureRight24 = null;
        #endregion
        #region Image ArrowAzureRight32
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku arrow-azure-right-32.png.
        /// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
        /// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
        /// Případně je možno vyvolat metodu ArrowAzureRight32_Reset(), která zajistí regenerování obrázku z jeho definice.
        /// Bezpečnější je používání property ArrowAzureRight32, která vrací vždy nový objekt.
        /// Pro používání pro Button.Image, kde bude nastavováno Button.Enabled = false; je třeba použít property ArrowAzureRight32_FromFile.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\DavidPrac\VSProjects\ReportEditor\Reporting.Green\Pics\source\arrow-azure-right-32.png
        /// </remarks>
        public static System.Drawing.Image ArrowAzureRight32_Cached
        {
            get
            {
                if (_ArrowAzureRight32 == null) _ArrowAzureRight32 = ArrowAzureRight32;
                return _ArrowAzureRight32;
            }
        }
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku arrow-azure-right-32.png.
        /// Nelze používat jako Image pro Buttony, kde bude nastavováno Enabled = false (pak dojde k chybě .NET: Ot of memory).
        /// Pak je třeba použít Image ArrowAzureRight32_FromFile.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití ArrowAzureRight32_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property ArrowAzureRight32_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\DavidPrac\VSProjects\ReportEditor\Reporting.Green\Pics\source\arrow-azure-right-32.png
        /// </remarks>
        public static System.Drawing.Image ArrowAzureRight32 { get { return _ImageCreateFrom(_ArrowAzureRight32_string, null); } }
        /// <summary>
        /// Vrátí obrázek, načtený ze souboru arrow-azure-right-32.png.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití ArrowAzureRight32_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property ArrowAzureRight32_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\DavidPrac\VSProjects\ReportEditor\Reporting.Green\Pics\source\arrow-azure-right-32.png
        /// </remarks>
        public static System.Drawing.Image ArrowAzureRight32_FromFile { get { return _ImageCreateFrom(_ArrowAzureRight32_string, "arrow-azure-right-32.png"); } }
        /// <summary>
        /// Vygeneruje a vrátí string, který definuje obsah souboru ArrowAzureRight32
        /// </summary>
        /// <returns></returns>
        private static string _ArrowAzureRight32_string()
        {
            System.Text.StringBuilder sb = new System.Text.StringBuilder(1608);
            sb.Append("iVBORw0KGgoAAAANSUhEUgAAABAAAAAgCAYAAAAbifjMAAAABGdBTUEAAK/INwWK6QAAAAlwSFlzAAAOwgAADsIBFShKgAAAAA10RVh0U291cmNlAE51dm9sYaxPNfEA");
            sb.Append("AAAadEVYdFNvZnR3YXJlAFBhaW50Lk5FVCB2My41LjExR/NCNwAABBdJREFUSEvNk31MW1UUwF+3CeqMRjSl7WtfG2TjwwwwLo5oEMe6GTSbZvKXiWYkLlETDDilGYzS");
            sb.Append("Flqg9GP0g0LpoC0UNixldYOV8FGKDhYwc5vbAogZEqpFLOpi/A7H8/AaWYSN/bdfctOX3vM795xz36PuHbiFciq+qBx/y6n495Xk37uAyDG4HsHnLbziCrKzQVBixTJM");
            sb.Append("MMQtUrzNk1XE8GQasrsBuO/Jn00sqZp/x+ODjHJDhFuoPMQ/Vr1ZoKwlEXeAWyDfm6rQRwdvzIJt5AIklmjn4j9U5wmrDZsE5ToSdRu4hQppslIfPTnzJUze/AkUPYMg");
            sb.Append("Ka2d5MmqpYyhjsMYrSRyHeKLlNJklTHaMj0FoaVFuLy0BAXeHhCW1l7kl+meeTRfRdHVFhK9BvFHKnK2qQzfm65dg66FMPQufgfnFxbgDU/3Ml2mHxAojEkCVR2JXgOe");
            sb.Append("TC0RHK0a2O/uBDO2YZubA/9CBAbCYXi1uXOZVhzvotVmhtas0wpdqefwjlZliUprp/a3+0A9PQ3qmRnwRiLg/+oG7LW3/y5QmRzCGutjIl0jsVbBL6uhxKZ6Dv+YNo9R");
            sb.Append("GmcPeM9C0eWrUHx9Erowiev6FGRa3L8KKi0aTPCwyOgg5ir4ci1Fq4z38eW6tyQaczTXdw7eHP8c3r30BXR+EwbLxSuQYXbepGsaShhz8/2MqYWYqxAo9BStMcXi0D6Q");
            sb.Append("aG0/ZJ8OwIv4XhyauASnMEnFhc8gxexcEumaDmOCWKLdikBlpHBgW+lKkyah7sQfmWcGYWffJ/A6VtMRngcZ+6JZXFNMXctTRLkVYZWVEmrrY2iNpURsaPotrbsPUs8G");
            sb.Append("IS0QgoIrOJexCdhua53FBLuI8h/CWhsl0jVswWHlp5taInt8AUg5MwTp50LwfHAUsnoGIMXe/jPKxYzF+SDR/gFFNsEmvOuDyQbHfH5vEPYNjkFabwiyh8cgOxCEbY2e");
            sb.Append("X1DWim3uhzABMQlx+XIcoDUnUWe/mufvg5eCYysns3JOfwiSHR1/omxjrK44XMQiCGvq2d7TJdqGCempjyF3lbxv+Dw86fzoL5RPoyj8n8yCCWhc3TscHcu7+0cgo28E");
            sb.Append("srHn3NAopLf5QGxyDmHJqWvKLNj7bpGhaTHJ2wsZgRF4AU9+eWQMnj7pZ+UJFHfiPoleAxyglKlrju7w96/IB0bHYRe+zhIz3rfVJU1weznrns4i0tulErMz+lzfMLyC");
            sb.Append("95zlD0BCvftrlF6T2D0csa2VRK4DlidNsLqiucOfwp7eQXjC1raI8mFJk2ez2OomUbdBdPxEFp74bSaWnWRv/xHlI+LGtlhxwx1O/hfG1Pw4Y3bqxfXucZRLseSt+Ex2");
            sb.Append("NwD7faP4AK44sbU15q5kFqyATbCy2J5xcGTn3oai/gaGrxlbFVSqEAAAAABJRU5ErkJggg==");
            return sb.ToString();
        }
        /// <summary>
        /// Resetuje obrázek v paměti.
        /// Následující použití property ArrowAzureRight32_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
        /// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
        /// </summary>
        public static void ArrowAzureRight32_Reset()
        {
            _ArrowAzureRight32 = null;
        }
        /// <summary>
        /// Úložiště objektu v paměti, při prvním použití ArrowAzureRight32_Direct je objekt naplněn a následně využíván.
        /// </summary>
        private static System.Drawing.Image _ArrowAzureRight32 = null;
        #endregion
        #region Image ArrowAzureUp16
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku arrow-azure-up-16.png.
        /// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
        /// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
        /// Případně je možno vyvolat metodu ArrowAzureUp16_Reset(), která zajistí regenerování obrázku z jeho definice.
        /// Bezpečnější je používání property ArrowAzureUp16, která vrací vždy nový objekt.
        /// Pro používání pro Button.Image, kde bude nastavováno Button.Enabled = false; je třeba použít property ArrowAzureUp16_FromFile.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\DavidPrac\VSProjects\ReportEditor\Reporting.Green\Pics\source\arrow-azure-up-16.png
        /// </remarks>
        public static System.Drawing.Image ArrowAzureUp16_Cached
        {
            get
            {
                if (_ArrowAzureUp16 == null) _ArrowAzureUp16 = ArrowAzureUp16;
                return _ArrowAzureUp16;
            }
        }
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku arrow-azure-up-16.png.
        /// Nelze používat jako Image pro Buttony, kde bude nastavováno Enabled = false (pak dojde k chybě .NET: Ot of memory).
        /// Pak je třeba použít Image ArrowAzureUp16_FromFile.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití ArrowAzureUp16_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property ArrowAzureUp16_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\DavidPrac\VSProjects\ReportEditor\Reporting.Green\Pics\source\arrow-azure-up-16.png
        /// </remarks>
        public static System.Drawing.Image ArrowAzureUp16 { get { return _ImageCreateFrom(_ArrowAzureUp16_string, null); } }
        /// <summary>
        /// Vrátí obrázek, načtený ze souboru arrow-azure-up-16.png.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití ArrowAzureUp16_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property ArrowAzureUp16_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\DavidPrac\VSProjects\ReportEditor\Reporting.Green\Pics\source\arrow-azure-up-16.png
        /// </remarks>
        public static System.Drawing.Image ArrowAzureUp16_FromFile { get { return _ImageCreateFrom(_ArrowAzureUp16_string, "arrow-azure-up-16.png"); } }
        /// <summary>
        /// Vygeneruje a vrátí string, který definuje obsah souboru ArrowAzureUp16
        /// </summary>
        /// <returns></returns>
        private static string _ArrowAzureUp16_string()
        {
            System.Text.StringBuilder sb = new System.Text.StringBuilder(844);
            sb.Append("iVBORw0KGgoAAAANSUhEUgAAABAAAAAICAYAAADwdn+XAAAABGdBTUEAAK/INwWK6QAAAAlwSFlzAAAOwgAADsIBFShKgAAAAA10RVh0U291cmNlAE51dm9sYaxPNfEA");
            sb.Append("AAAadEVYdFNvZnR3YXJlAFBhaW50Lk5FVCB2My41LjExR/NCNwAAAdpJREFUKFNj+P//P4NQTC4Df2A6o0BIJqNwfCGDSGo5g3BKJYtIenWORG59iUR5O7tERRuDRHkr");
            sb.Append("CDMC+YxSDX1gvVADchgEw7MZhOKKGEQzaxiEEssZhRLKJsfOW/k/YOHK/2L5jQslKjvZpJr6GSTrehgkq7rANNwAkdQyBpH0CgaxnDoGkYxqTqH4ssXZS9f9n/nw4X/v");
            sb.Append("46f/689a8h9o6zqgrfzSHdMYpNumMsh0TkcYIJpTyyCaVQM0pIpdNLVqa/X67f9XPHvy3+XQif+qW/f9tzl47L/5krX/pRv6Dki3TBaU6ZzBIDthHpIBQM3CyeWSUpk1");
            sb.Append("h9p3Hvi/483z//Fnz/9Xmzz/vzoQO+07+t/hyIn/1ms2/5dtm3JWun2aiuyEuQgDRNIq1dTymk7OPnLy/6lPb/7XXLv633jKgv/iJa09MhUdzR7zVv133Xvkv8uxk/+d");
            sb.Append("N+/8r9w356Js3xxDuAHqJa1X11+6+v/hz3f/p9++/t980rz/YnlNzZI1XcBQ72CQqu4ts5i17I/x1r1gQzx3H/yvMm3RfbgBalUdd4NnLf3tPnPRD/2OqR/FC1uKgJgB");
            sb.Append("bEBlB4NkbR8D0O8pCpPmv1Wcuey77qK1v5RnLn3y//9/BgDbX/6QlxSfuwAAAABJRU5ErkJggg==");
            return sb.ToString();
        }
        /// <summary>
        /// Resetuje obrázek v paměti.
        /// Následující použití property ArrowAzureUp16_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
        /// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
        /// </summary>
        public static void ArrowAzureUp16_Reset()
        {
            _ArrowAzureUp16 = null;
        }
        /// <summary>
        /// Úložiště objektu v paměti, při prvním použití ArrowAzureUp16_Direct je objekt naplněn a následně využíván.
        /// </summary>
        private static System.Drawing.Image _ArrowAzureUp16 = null;
        #endregion
        #region Image ArrowAzureUp24
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku arrow-azure-up-24.png.
        /// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
        /// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
        /// Případně je možno vyvolat metodu ArrowAzureUp24_Reset(), která zajistí regenerování obrázku z jeho definice.
        /// Bezpečnější je používání property ArrowAzureUp24, která vrací vždy nový objekt.
        /// Pro používání pro Button.Image, kde bude nastavováno Button.Enabled = false; je třeba použít property ArrowAzureUp24_FromFile.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\DavidPrac\VSProjects\ReportEditor\Reporting.Green\Pics\source\arrow-azure-up-24.png
        /// </remarks>
        public static System.Drawing.Image ArrowAzureUp24_Cached
        {
            get
            {
                if (_ArrowAzureUp24 == null) _ArrowAzureUp24 = ArrowAzureUp24;
                return _ArrowAzureUp24;
            }
        }
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku arrow-azure-up-24.png.
        /// Nelze používat jako Image pro Buttony, kde bude nastavováno Enabled = false (pak dojde k chybě .NET: Ot of memory).
        /// Pak je třeba použít Image ArrowAzureUp24_FromFile.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití ArrowAzureUp24_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property ArrowAzureUp24_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\DavidPrac\VSProjects\ReportEditor\Reporting.Green\Pics\source\arrow-azure-up-24.png
        /// </remarks>
        public static System.Drawing.Image ArrowAzureUp24 { get { return _ImageCreateFrom(_ArrowAzureUp24_string, null); } }
        /// <summary>
        /// Vrátí obrázek, načtený ze souboru arrow-azure-up-24.png.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití ArrowAzureUp24_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property ArrowAzureUp24_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\DavidPrac\VSProjects\ReportEditor\Reporting.Green\Pics\source\arrow-azure-up-24.png
        /// </remarks>
        public static System.Drawing.Image ArrowAzureUp24_FromFile { get { return _ImageCreateFrom(_ArrowAzureUp24_string, "arrow-azure-up-24.png"); } }
        /// <summary>
        /// Vygeneruje a vrátí string, který definuje obsah souboru ArrowAzureUp24
        /// </summary>
        /// <returns></returns>
        private static string _ArrowAzureUp24_string()
        {
            System.Text.StringBuilder sb = new System.Text.StringBuilder(1380);
            sb.Append("iVBORw0KGgoAAAANSUhEUgAAABgAAAAMCAYAAAB4MH11AAAABGdBTUEAAK/INwWK6QAAAAlwSFlzAAAOwgAADsIBFShKgAAAAA10RVh0U291cmNlAE51dm9sYaxPNfEA");
            sb.Append("AAAadEVYdFNvZnR3YXJlAFBhaW50Lk5FVCB2My41LjExR/NCNwAAA21JREFUOE9jgAHBiGwwzWkexcxlHcPM7RDPzO2SyCiSXMIgmlMLwlxiOXW2Yvn1TmKFjbwSpa0M");
            sb.Append("QJpBvKiRUSyvjlksr55ZLLeRmT+0iEGytgdsFgoQTStiEIrJZRCKBuK4fAbhhEIGkbRSBtFcoOGZNfzSRY1Zdj0zrtpNnHNLpqqjTLykRViqtptBsrqDQbIKiKs7gQZ3");
            sb.Append("M0g19DFIt0yEmooHiBc1MAinVDIIp1YKyhQ0VvpOW/ik4/TZ/0kHj/7XnjT3lXRNV4tEebu4VMMkoIGToLqIBOLF9UBflDKIpFfLKJa0dEbOW/5u8qUr/3MuXPlvtffo");
            sb.Append("f+ute/7rzlj8Sbapf5pkXY+KRFUXg0zHNKhuAkA0qwZoMDDcM6vVNCs7Z6QvXf9x7o1b/0svX/9vs+vQf+3Ne/8b7zr8327ngf+G81d+VeyctkSqeaKeVNNERpnuGVBT");
            sb.Append("cACR9CoGgdACRmCw6OlUd60sXbf928oHD/433br933/v4f86s5b+VJ+26IcV0BKQTxz3HP5vtnz9T6XeWVul26aYSbdOZpLpmw01DQ2ADAcGCzPQ5bYm9X27Wnfs/7P5");
            sb.Append("yZP/kx8+/J90+Ph/k2mL3kjX9fQrNPZ3OM1d+cJ7+wGwJc77gEG2dutf1SkLDsv0zHST6ZzBKjdxPtRUJAC0gFkir97VqXPa4WmHTvw59OrF/6VPH/8vPnH6v/m0hc9l");
            sb.Append("antqJSo6RCUquwVVWqcUWs9d8cBpy97/lnuO/Hc9cPy/w6Zdf7VmLzstN3FeINACVqixCCCcXCGsVdO1rn7L7v9bgcGy5P69/zXHT/63njL/gVRlZx7QcAGJSmByrOlh");
            sb.Append("kKzr55Fvn5qkP2vpTb1VW/4bbt373wkYhNbrt/9XnbF0p2z/PDGosQgATOu8iuVt9Vbd047aT5pzwmri7BM6HVO2AQ2PEi9t4xQva4OqZGCQrO9nkGqaxCbbNcNPftK8");
            sb.Append("jQrTF59Qnb38hMbcFceUZizpkJu0kB+qFAEkq8E5U0A0r0FZLL9RVayoWRVoqIxkVScb0PUMUnWI3AmMUAaZ1skMwDBnke2dJSXbN1tVtn+uKjBolOWmLhSSn7mEEaoU");
            sb.Append("ASQqWsBZX6wAiAubGIA5lQGYkYBB0gVVgQlk+2YB8WwG2f45DLIT5jKAIhdoAQPQAqgKBgYAiqlmcJQAvSsAAAAASUVORK5CYII=");
            return sb.ToString();
        }
        /// <summary>
        /// Resetuje obrázek v paměti.
        /// Následující použití property ArrowAzureUp24_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
        /// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
        /// </summary>
        public static void ArrowAzureUp24_Reset()
        {
            _ArrowAzureUp24 = null;
        }
        /// <summary>
        /// Úložiště objektu v paměti, při prvním použití ArrowAzureUp24_Direct je objekt naplněn a následně využíván.
        /// </summary>
        private static System.Drawing.Image _ArrowAzureUp24 = null;
        #endregion
        #region Image ArrowAzureUp32
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku arrow-azure-up-32.png.
        /// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
        /// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
        /// Případně je možno vyvolat metodu ArrowAzureUp32_Reset(), která zajistí regenerování obrázku z jeho definice.
        /// Bezpečnější je používání property ArrowAzureUp32, která vrací vždy nový objekt.
        /// Pro používání pro Button.Image, kde bude nastavováno Button.Enabled = false; je třeba použít property ArrowAzureUp32_FromFile.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\DavidPrac\VSProjects\ReportEditor\Reporting.Green\Pics\source\arrow-azure-up-32.png
        /// </remarks>
        public static System.Drawing.Image ArrowAzureUp32_Cached
        {
            get
            {
                if (_ArrowAzureUp32 == null) _ArrowAzureUp32 = ArrowAzureUp32;
                return _ArrowAzureUp32;
            }
        }
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku arrow-azure-up-32.png.
        /// Nelze používat jako Image pro Buttony, kde bude nastavováno Enabled = false (pak dojde k chybě .NET: Ot of memory).
        /// Pak je třeba použít Image ArrowAzureUp32_FromFile.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití ArrowAzureUp32_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property ArrowAzureUp32_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\DavidPrac\VSProjects\ReportEditor\Reporting.Green\Pics\source\arrow-azure-up-32.png
        /// </remarks>
        public static System.Drawing.Image ArrowAzureUp32 { get { return _ImageCreateFrom(_ArrowAzureUp32_string, null); } }
        /// <summary>
        /// Vrátí obrázek, načtený ze souboru arrow-azure-up-32.png.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití ArrowAzureUp32_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property ArrowAzureUp32_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\DavidPrac\VSProjects\ReportEditor\Reporting.Green\Pics\source\arrow-azure-up-32.png
        /// </remarks>
        public static System.Drawing.Image ArrowAzureUp32_FromFile { get { return _ImageCreateFrom(_ArrowAzureUp32_string, "arrow-azure-up-32.png"); } }
        /// <summary>
        /// Vygeneruje a vrátí string, který definuje obsah souboru ArrowAzureUp32
        /// </summary>
        /// <returns></returns>
        private static string _ArrowAzureUp32_string()
        {
            System.Text.StringBuilder sb = new System.Text.StringBuilder(1732);
            sb.Append("iVBORw0KGgoAAAANSUhEUgAAACAAAAAQCAYAAAB3AH1ZAAAABGdBTUEAAK/INwWK6QAAAAlwSFlzAAAOwgAADsIBFShKgAAAAA10RVh0U291cmNlAE51dm9sYaxPNfEA");
            sb.Append("AAAadEVYdFNvZnR3YXJlAFBhaW50Lk5FVCB2My41LjExR/NCNwAABHVJREFUSEvNlXtM21UUx+9EDI7EF/T9skw0Q4mwhYSokQWdrNkWnyHGGDdxExblXV4D+qS/0tJC");
            sb.Append("Cy2lrDAY22RsC8irwCwwqsCcbIkIOiGboDCBqaxZosmmx/PrfjPLGFk2/cNvcv5oeu/9fM/5nXsuuVUhO9LIY+9h7EjHyCAhSVkkdJecsFJyCWtPnn8NJ0tFuHJNADtD");
            sb.Append("KWVnqsM5OdpAbj7l/4+1p5Bw9+r9wSs0EF6RkfCKywhPYSJ8Vbl/zR0VsjOdhCZlIjibhO6Wk9DkHH/QouG8fO397DTF23y5dliYqxvjyLUpCAyigbSuw0v9cD7C+cq7");
            sb.Append("gK8mbp7GD+dkq9ayUxXJ0lzd/IdHPoWUjl6QKk2/cXN0BWjgIRoq0FqYXf+h/PAcdTDr4+L8J/L1SwVuDxybmwP5N5PwXHMbiFVmH7egtBQzDvnX2d4sTqaSYMa0ATbC");
            sb.Append("jZFK8xWq3wutFy/C7jNfw8Y+L2waHIbnj3dCGGX7AyvgQgNSvtZKBFQVc8o9ipujIqyPigk2mwDhdTEay+81X45B+8ICJJ8Zh409QxDRPQhRvUMQPzgCmzr6INxUcxUN");
            sb.Append("tKGBJ/kaGxGZnMxpdyk689DkQsJOVzzNSi0++oqp9lrzxLfQvrgAGeOTkDB0CmI7PBDZ2gPruwbgWfdJiD85Ci/3DkCEveEvfonVI9BVxSb8cA8muLkaEmYrIwiO4aQq");
            sb.Append("PNut9X92T5+HToQXTH4H7351FuLbeiDMUH1NTFVdfaGlE+JOfAFRWBHaxBaPFyKdB0FI2caEevtL4grnfSKLizn9DqIzF6j1a7DkCbw05dmddc3g/WkOuhBOTU1D5vgE");
            sb.Append("bEO4VGu9wttrqMJvro821Czvcg9AQv/IP5XYOjQMGxpbQGysmRKW1SSKrXUB4sp6hrKK8IoRjlwVgMPkdUmW5lzmkXYYW1yEE5eWwDE7C7qpKXizzY1wC93xWr7C9Ahf");
            sb.Append("UxHMKzZnR5qci4ntfbAZTUQzPbH981GIxav6eIVrVmiufR8NBIntjQztNkIDAfjN33kqTz+j7/bAucvL4P31Ehz9eR4cF85D4rFOECvNSwiX43BZiwb8Awa7/QG+2pIU");
            sb.Append("bnTMyHBN3Gde2MCYeG3kNMS1umGdrXFRXLk/FQ0EMriVwm5/GMOTcvA4jM7Ng3vuR2iZvQCu6e/hreZWkBSZZhD+AYIfpAfODfFVFURosAcKSqreCDM5J6IaWmB9ay9E");
            sb.Append("dfX7zWzzjkAsGpNUNpxCA48y21YK73oQJ0ttekZtXoox2HzRRrsvuqzaF1lquywoMp5G+KsCyhJAj9dbJaBsJOzA4TVCo+NFock5ILbuX5ZUH/BJHU2+8NpDGId/wd8u");
            sb.Append("ib0pmNmyUpg99oCGjQ9MPDtDLeNkaWUceYmMk0ttwTEbgWW/LfyGhIZqInE0EVF57TpR+b4EUYVLJrLUydCMDDPfjAaEEucnzOpVhAauR7YWB5EOryRFuAX4uNCv2k1l");
            sb.Append("X030nUcDGPsIffVElnqCBgjdfGgADR5iVv4vRMjf/0k0kt6/3oYAAAAASUVORK5CYII=");
            return sb.ToString();
        }
        /// <summary>
        /// Resetuje obrázek v paměti.
        /// Následující použití property ArrowAzureUp32_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
        /// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
        /// </summary>
        public static void ArrowAzureUp32_Reset()
        {
            _ArrowAzureUp32 = null;
        }
        /// <summary>
        /// Úložiště objektu v paměti, při prvním použití ArrowAzureUp32_Direct je objekt naplněn a následně využíván.
        /// </summary>
        private static System.Drawing.Image _ArrowAzureUp32 = null;
        #endregion
        #region Image ArrowBlueDown16
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku arrow-blue-down-16.png.
        /// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
        /// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
        /// Případně je možno vyvolat metodu ArrowBlueDown16_Reset(), která zajistí regenerování obrázku z jeho definice.
        /// Bezpečnější je používání property ArrowBlueDown16, která vrací vždy nový objekt.
        /// Pro používání pro Button.Image, kde bude nastavováno Button.Enabled = false; je třeba použít property ArrowBlueDown16_FromFile.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\DavidPrac\VSProjects\ReportEditor\Reporting.Green\Pics\source\arrow-blue-down-16.png
        /// </remarks>
        public static System.Drawing.Image ArrowBlueDown16_Cached
        {
            get
            {
                if (_ArrowBlueDown16 == null) _ArrowBlueDown16 = ArrowBlueDown16;
                return _ArrowBlueDown16;
            }
        }
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku arrow-blue-down-16.png.
        /// Nelze používat jako Image pro Buttony, kde bude nastavováno Enabled = false (pak dojde k chybě .NET: Ot of memory).
        /// Pak je třeba použít Image ArrowBlueDown16_FromFile.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití ArrowBlueDown16_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property ArrowBlueDown16_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\DavidPrac\VSProjects\ReportEditor\Reporting.Green\Pics\source\arrow-blue-down-16.png
        /// </remarks>
        public static System.Drawing.Image ArrowBlueDown16 { get { return _ImageCreateFrom(_ArrowBlueDown16_string, null); } }
        /// <summary>
        /// Vrátí obrázek, načtený ze souboru arrow-blue-down-16.png.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití ArrowBlueDown16_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property ArrowBlueDown16_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\DavidPrac\VSProjects\ReportEditor\Reporting.Green\Pics\source\arrow-blue-down-16.png
        /// </remarks>
        public static System.Drawing.Image ArrowBlueDown16_FromFile { get { return _ImageCreateFrom(_ArrowBlueDown16_string, "arrow-blue-down-16.png"); } }
        /// <summary>
        /// Vygeneruje a vrátí string, který definuje obsah souboru ArrowBlueDown16
        /// </summary>
        /// <returns></returns>
        private static string _ArrowBlueDown16_string()
        {
            System.Text.StringBuilder sb = new System.Text.StringBuilder(808);
            sb.Append("iVBORw0KGgoAAAANSUhEUgAAABAAAAAICAYAAADwdn+XAAAABGdBTUEAAK/INwWK6QAAAAlwSFlzAAAOwwAADsMBx2+oZAAAAA10RVh0U291cmNlAE51dm9sYaxPNfEA");
            sb.Append("AAAadEVYdFNvZnR3YXJlAFBhaW50Lk5FVCB2My41LjExR/NCNwAAAcFJREFUKFNNkV1Ik2EYhu/Z0lSyHZiKPxk4ikSQOhIUPSqSqCTmyh/U5kSc3yebYBmElhNE9ECI");
            sb.Append("qINEEIRAkTrTIFIUZYpCjU/wp/w5KKEMzbbl5nb3NMF28L7Pwftc1/3yPCAJw50pd57j08ElVfMmVmvfUbJkxd1NoOYnUOcBLF6pPnNUY2Bbp4YOTrfQf9LOlX9sWJBs");
            sb.Append("dm28nt3l4m+y7cMfpitbQZg2W8MCqwe6Wm9D2iO/z/CQPOcks3vJGAe3jwW4NnM5o8z98dXEHt99JS2jh0yx7xBVOx36ek9rrjMQvNApsJyL3eQpB1fRyPz/guJZkSwa");
            sb.Append("48xrC863+xzUyKKXQcaqXp5p9oeMkpr6lMyUqm+ihgbmQuERG76uTwG3NaB03aAv/zbxYMTHPpckdsijQia3k+kiOKFwTpIzoApjC0QICt8ABWOAaVkG9isBFXuj1qFD");
            sb.Append("PnlPGrvIs49JncJx2JkEWxC4/wMo+xIhKBgGzvcAV4aAq5NAbSAGltCAqZ8sfC4NdaFhNDEelbIZs4TcWgDurUQKRgDjMyCrD8h5IQ3zkG9Gw8Z2vcougWNR/hm4MQ3c");
            sb.Append("dAElbhGsCkv8BWlYCdi/DHOdAAAAAElFTkSuQmCC");
            return sb.ToString();
        }
        /// <summary>
        /// Resetuje obrázek v paměti.
        /// Následující použití property ArrowBlueDown16_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
        /// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
        /// </summary>
        public static void ArrowBlueDown16_Reset()
        {
            _ArrowBlueDown16 = null;
        }
        /// <summary>
        /// Úložiště objektu v paměti, při prvním použití ArrowBlueDown16_Direct je objekt naplněn a následně využíván.
        /// </summary>
        private static System.Drawing.Image _ArrowBlueDown16 = null;
        #endregion
        #region Image ArrowBlueDown24
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku arrow-blue-down-24.png.
        /// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
        /// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
        /// Případně je možno vyvolat metodu ArrowBlueDown24_Reset(), která zajistí regenerování obrázku z jeho definice.
        /// Bezpečnější je používání property ArrowBlueDown24, která vrací vždy nový objekt.
        /// Pro používání pro Button.Image, kde bude nastavováno Button.Enabled = false; je třeba použít property ArrowBlueDown24_FromFile.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\DavidPrac\VSProjects\ReportEditor\Reporting.Green\Pics\source\arrow-blue-down-24.png
        /// </remarks>
        public static System.Drawing.Image ArrowBlueDown24_Cached
        {
            get
            {
                if (_ArrowBlueDown24 == null) _ArrowBlueDown24 = ArrowBlueDown24;
                return _ArrowBlueDown24;
            }
        }
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku arrow-blue-down-24.png.
        /// Nelze používat jako Image pro Buttony, kde bude nastavováno Enabled = false (pak dojde k chybě .NET: Ot of memory).
        /// Pak je třeba použít Image ArrowBlueDown24_FromFile.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití ArrowBlueDown24_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property ArrowBlueDown24_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\DavidPrac\VSProjects\ReportEditor\Reporting.Green\Pics\source\arrow-blue-down-24.png
        /// </remarks>
        public static System.Drawing.Image ArrowBlueDown24 { get { return _ImageCreateFrom(_ArrowBlueDown24_string, null); } }
        /// <summary>
        /// Vrátí obrázek, načtený ze souboru arrow-blue-down-24.png.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití ArrowBlueDown24_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property ArrowBlueDown24_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\DavidPrac\VSProjects\ReportEditor\Reporting.Green\Pics\source\arrow-blue-down-24.png
        /// </remarks>
        public static System.Drawing.Image ArrowBlueDown24_FromFile { get { return _ImageCreateFrom(_ArrowBlueDown24_string, "arrow-blue-down-24.png"); } }
        /// <summary>
        /// Vygeneruje a vrátí string, který definuje obsah souboru ArrowBlueDown24
        /// </summary>
        /// <returns></returns>
        private static string _ArrowBlueDown24_string()
        {
            System.Text.StringBuilder sb = new System.Text.StringBuilder(1252);
            sb.Append("iVBORw0KGgoAAAANSUhEUgAAABgAAAAMCAYAAAB4MH11AAAABGdBTUEAAK/INwWK6QAAAAlwSFlzAAAOwwAADsMBx2+oZAAAAA10RVh0U291cmNlAE51dm9sYaxPNfEA");
            sb.Append("AAAadEVYdFNvZnR3YXJlAFBhaW50Lk5FVCB2My41LjExR/NCNwAAAw5JREFUOE+NlGtMjQEYx/9v5+iQrlg1dLU+YJjZaNhcF41uKBwkTDrndE+uScoac9n6QDOXtRaz");
            sb.Append("meGDy6ZEuVUuy4Rcmk4f0CyiOp3D+/49OKy5bP23/573w7Pf87zP+zwvfiuuEphXLa4BIm8DCxuAmAfA4kZnwj9k6gHMdiBVBdIo0el08V9aJgUiqt0x90YwIm6FIrI+");
            sb.Append("FFH3/RH7QIf4l0Ci1ZkoWtkEbLCJu3Uw2f1gUcMEHAYLQyR6IuNfBWZXDXaLrc0NXHOvOii5sXbEhsc3fVY3nVWWNEUh5qkrVrQ5E0XrpfPELj1SeucoFsdpJU2rH5DJ");
            sb.Append("OkM2b+gymC+FPJyZfTS9apjv8roLWcetLLv7mftqurm24oMWnGF97rKsZR2Mre5IagfWCnxN90C9yZYwJPfLI49cVfPYRAbtJgMKSUMWK2Gmn5PaR7Ou6w3Rd6On5jxt");
            sb.Append("KLnSoV5+pbKkQaOxvJsB2e2tuqQ3OVLAWwq4DzLbkkPyHM1hhRp988jQYnJUMTWvzXzskk6jvIGrk9pHs66L6/VY+DBidOqLmp1nP6gnG1XmVZERpXb6b+x8q6z/WGww");
            sb.Append("9+SP2eWwTtij0V/gwdJ5UBG1wRvZIPOPg4kGKeCE/ql5dbI5zQqin00JMFsvplV02o/Uq0w5T07c/5VeOb029yxHT1D+T3hgETm8gF8GZvOaQGeIdf+H/1LMI1nRlwoS");
            sb.Append("Wsf5W95VJB7v6jpQqzKhQmACHpRNem4mR8q8fXfQJjM/J9DJMneXHyvaL8U/B7xvAcb2Ud7mj4diDvd+KqzUGHmUHLqdHFEgcRt79BksF/jYH3vfb/gvrZK1jH4l8bOf");
            sb.Append("m8VeNLNEa99ymZx/jPTZyg5dOg8KPBDr+gu/J0nTzgCTTgDjS4GJR+WjX4KS9B5I1oYa0pk7YQ9bxu1lm2smC76vovL9go0t8he4DyyS0cY/AZY2Ayuksb8UfgZec8rk");
            sb.Append("oVgBssQ5SgulaPgpOSyH/BbkeExcIF3Hin2QogFRd4AUuYvZVxXMvKYgvEpxNUlDy1//ZAL4BhxIfY4VtIXzAAAAAElFTkSuQmCC");
            return sb.ToString();
        }
        /// <summary>
        /// Resetuje obrázek v paměti.
        /// Následující použití property ArrowBlueDown24_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
        /// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
        /// </summary>
        public static void ArrowBlueDown24_Reset()
        {
            _ArrowBlueDown24 = null;
        }
        /// <summary>
        /// Úložiště objektu v paměti, při prvním použití ArrowBlueDown24_Direct je objekt naplněn a následně využíván.
        /// </summary>
        private static System.Drawing.Image _ArrowBlueDown24 = null;
        #endregion
        #region Image ArrowBlueDown32
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku arrow-blue-down-32.png.
        /// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
        /// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
        /// Případně je možno vyvolat metodu ArrowBlueDown32_Reset(), která zajistí regenerování obrázku z jeho definice.
        /// Bezpečnější je používání property ArrowBlueDown32, která vrací vždy nový objekt.
        /// Pro používání pro Button.Image, kde bude nastavováno Button.Enabled = false; je třeba použít property ArrowBlueDown32_FromFile.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\DavidPrac\VSProjects\ReportEditor\Reporting.Green\Pics\source\arrow-blue-down-32.png
        /// </remarks>
        public static System.Drawing.Image ArrowBlueDown32_Cached
        {
            get
            {
                if (_ArrowBlueDown32 == null) _ArrowBlueDown32 = ArrowBlueDown32;
                return _ArrowBlueDown32;
            }
        }
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku arrow-blue-down-32.png.
        /// Nelze používat jako Image pro Buttony, kde bude nastavováno Enabled = false (pak dojde k chybě .NET: Ot of memory).
        /// Pak je třeba použít Image ArrowBlueDown32_FromFile.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití ArrowBlueDown32_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property ArrowBlueDown32_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\DavidPrac\VSProjects\ReportEditor\Reporting.Green\Pics\source\arrow-blue-down-32.png
        /// </remarks>
        public static System.Drawing.Image ArrowBlueDown32 { get { return _ImageCreateFrom(_ArrowBlueDown32_string, null); } }
        /// <summary>
        /// Vrátí obrázek, načtený ze souboru arrow-blue-down-32.png.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití ArrowBlueDown32_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property ArrowBlueDown32_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\DavidPrac\VSProjects\ReportEditor\Reporting.Green\Pics\source\arrow-blue-down-32.png
        /// </remarks>
        public static System.Drawing.Image ArrowBlueDown32_FromFile { get { return _ImageCreateFrom(_ArrowBlueDown32_string, "arrow-blue-down-32.png"); } }
        /// <summary>
        /// Vygeneruje a vrátí string, který definuje obsah souboru ArrowBlueDown32
        /// </summary>
        /// <returns></returns>
        private static string _ArrowBlueDown32_string()
        {
            System.Text.StringBuilder sb = new System.Text.StringBuilder(1560);
            sb.Append("iVBORw0KGgoAAAANSUhEUgAAACAAAAAQCAYAAAB3AH1ZAAAABGdBTUEAAK/INwWK6QAAAAlwSFlzAAAOwwAADsMBx2+oZAAAAA10RVh0U291cmNlAE51dm9sYaxPNfEA");
            sb.Append("AAAadEVYdFNvZnR3YXJlAFBhaW50Lk5FVCB2My41LjExR/NCNwAAA/VJREFUSEvNlX1M1HUcx9/AcYSQSLJZLonckoWbzJVRLf4wMDghJJAg8AzweJCDA+Q0k5yCgisy");
            sb.Append("23IjFDed0x62Zlr+U5T4EIU85CnEQ1nYTQX0EBx3ntxx7z53HBt/YFKzrff22fd32/e71+f58P+T6hQQexpYeQ6I/xFIOA8ktgPJBiC1y33pPlp/BygYAwodQBEnrNB9");
            sb.Append("/q1iBK46FYBXGl9EzNkVUDVFI+58NBLaXkbShRCgB0j/zX15GuVbxKxOB+aLA1HiQLxA4wQeIxYp30EuR+6pmO99oGrcGpDSZAzKaDUFrmk3Ba41mGarL93wTL70LVb/");
            sb.Append("EomsLg+o/3Q/mKL1Ao+SqPPuhIsTx6C130SRw+yp46iihMNi18SB3eKAr/vFNIo9HQDVmcb0ml5+bRjlvp/M/KDJwu0NZkZUXKUirbcbaZdToO5TIHPA/UiUJ3DtqAdy");
            sb.Append("LVHe2rstczbZ6V3ioN9Gcv52Mux9ObeRHkVsFQcecb+aRvHnFFj5Q/4CdXv/7i8HaBgY51e/k/s7yG2NNkbsvEFv9ZU+rDFqkH3dB5qhCXih2Qs5liTfQmtHWJWdT1aS");
            sb.Append("D28ig3eQ4R+ST+0ifTdwWDJQLqZ006ZRvDReYrMSqpbMOakGY9nB62w22vlJJ1l5hiw+Oc5lu0aozO43IXNQD41pFvLMSmgsWQHFVuNLe+wMqyb9JXInfMke8gk5vYt5");
            sb.Append("E1qWCdxfzA27l16Vzk/vUCDx4mq/tK7utXv72dBr4yEDqTtJph51cEmVhcq8W7egGalGrnnLPL21P652nIsF7qcnF0gGFkvaH5O0K3S8ImnPgY4PueD3dcCplAtA+aAH");
            sb.Append("kntWeKVdbourGXSc6LSxvp1Uf04u/5hcWDFGpdZi8yqwji2qHGeoQCfhT9eQQe+4at4t8GQU02tm4Kl6vROotQFv9D3nmWFsiNxhchxps/HAz+SqQ2So1HVe+Tj99Q56");
            sb.Append("l5KznHBJ96J3ycC3XfAWgUejhB7/HD6pDJn5WFk+6muhUA9+Eb515O5HZ23c10ZG1wloM6kUuLPbnZEvlBJI89kF/J3Ys4CAdf8WPinnzGdcBdYNBSNruD5ks8Va9Y2d");
            sb.Append("da1k5F6JXOCPV5AhO+W7zAU/JhGHSdPNsN4zVbZJttzoXGis1Y9utN/ecJysbSGTDkvHS/Q+pbQIvFagwXI+YLhTGnEg57bMvH028h1bAvQcWvcp+eZnMnZ6jkrE7wl0");
            sb.Append("7n8DnyqtNGYpfVDAXGUxe2TB/CHQt6TWfg8GvPw48MJR4Jn9wNI6OeuBZQeB5w/Lrj8xcccJ0slG03KpWIT89nVFPqmEZmBVC/Ca81/0ooy1TFRqt0zUr+4LkwL+AoCj");
            sb.Append("P0etya+xAAAAAElFTkSuQmCC");
            return sb.ToString();
        }
        /// <summary>
        /// Resetuje obrázek v paměti.
        /// Následující použití property ArrowBlueDown32_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
        /// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
        /// </summary>
        public static void ArrowBlueDown32_Reset()
        {
            _ArrowBlueDown32 = null;
        }
        /// <summary>
        /// Úložiště objektu v paměti, při prvním použití ArrowBlueDown32_Direct je objekt naplněn a následně využíván.
        /// </summary>
        private static System.Drawing.Image _ArrowBlueDown32 = null;
        #endregion
        #region Image ArrowBlueLeft16
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku arrow-blue-left-16.png.
        /// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
        /// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
        /// Případně je možno vyvolat metodu ArrowBlueLeft16_Reset(), která zajistí regenerování obrázku z jeho definice.
        /// Bezpečnější je používání property ArrowBlueLeft16, která vrací vždy nový objekt.
        /// Pro používání pro Button.Image, kde bude nastavováno Button.Enabled = false; je třeba použít property ArrowBlueLeft16_FromFile.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\DavidPrac\VSProjects\ReportEditor\Reporting.Green\Pics\source\arrow-blue-left-16.png
        /// </remarks>
        public static System.Drawing.Image ArrowBlueLeft16_Cached
        {
            get
            {
                if (_ArrowBlueLeft16 == null) _ArrowBlueLeft16 = ArrowBlueLeft16;
                return _ArrowBlueLeft16;
            }
        }
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku arrow-blue-left-16.png.
        /// Nelze používat jako Image pro Buttony, kde bude nastavováno Enabled = false (pak dojde k chybě .NET: Ot of memory).
        /// Pak je třeba použít Image ArrowBlueLeft16_FromFile.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití ArrowBlueLeft16_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property ArrowBlueLeft16_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\DavidPrac\VSProjects\ReportEditor\Reporting.Green\Pics\source\arrow-blue-left-16.png
        /// </remarks>
        public static System.Drawing.Image ArrowBlueLeft16 { get { return _ImageCreateFrom(_ArrowBlueLeft16_string, null); } }
        /// <summary>
        /// Vrátí obrázek, načtený ze souboru arrow-blue-left-16.png.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití ArrowBlueLeft16_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property ArrowBlueLeft16_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\DavidPrac\VSProjects\ReportEditor\Reporting.Green\Pics\source\arrow-blue-left-16.png
        /// </remarks>
        public static System.Drawing.Image ArrowBlueLeft16_FromFile { get { return _ImageCreateFrom(_ArrowBlueLeft16_string, "arrow-blue-left-16.png"); } }
        /// <summary>
        /// Vygeneruje a vrátí string, který definuje obsah souboru ArrowBlueLeft16
        /// </summary>
        /// <returns></returns>
        private static string _ArrowBlueLeft16_string()
        {
            System.Text.StringBuilder sb = new System.Text.StringBuilder(820);
            sb.Append("iVBORw0KGgoAAAANSUhEUgAAAAgAAAAQCAYAAAArij59AAAABGdBTUEAAK/INwWK6QAAAAlwSFlzAAAOwwAADsMBx2+oZAAAAA10RVh0U291cmNlAE51dm9sYaxPNfEA");
            sb.Append("AAAadEVYdFNvZnR3YXJlAFBhaW50Lk5FVCB2My41LjExR/NCNwAAAchJREFUKFN90U1I03EcBvCHmVHDmIfw7aAUbmA1S93+UxuM0hT5X7aZh15I6TA6BJ7WIQ2GKQRh");
            sb.Append("hBfnEl1m2r+yBYHDInuxDCF1IZUlKtOYL6kgmB4SHr+woEt0+Jy+z+H5PT+Q/C9AeRBn+0PRkFDcV5tS3stEa6AOsHQBBSL/HpAnTJ2X3N5Btjyf5r7C4Gs53AHM4nA7");
            sb.Append("YAyczz8b+j2+scmWoSXuVroHJSCHXGEKqDlObf3p1BofLZCVzV+pU3qC8UC2XzlQ0hXriSzy5gSp3prnHvvDz7D1ZgGH/DkpRe3fWofm6H1H5voWqXc8jsJ6/whO9gOG");
            sb.Append("4x2RG/0zrAmThto16hyhGGxaHoo14NQrILU0OOlsi9FwjUz0rNBQ/iwKR9gEdRioeC87HG2z7CrSoplXf3J/A6n4lpnmevkdZW+z4fwogQIpablboq8YWD3oW2dGE2mu");
            sb.Append("X2aS+8MIXJF0CcgGtm7AHjqTdHp4y9i0ybTrpN6zQLg++YFjrYBVnmt/ApwY8CRfmKD59jaTr/wiqiZlqNIwUPZCCr0BVCmljnhTL0dpbNhgwrlZmboyEuceF2OAaxS6");
            sb.Append("qi/1ey/OU1f9o/GfX/wXsQPUYPElQMw2KgAAAABJRU5ErkJggg==");
            return sb.ToString();
        }
        /// <summary>
        /// Resetuje obrázek v paměti.
        /// Následující použití property ArrowBlueLeft16_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
        /// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
        /// </summary>
        public static void ArrowBlueLeft16_Reset()
        {
            _ArrowBlueLeft16 = null;
        }
        /// <summary>
        /// Úložiště objektu v paměti, při prvním použití ArrowBlueLeft16_Direct je objekt naplněn a následně využíván.
        /// </summary>
        private static System.Drawing.Image _ArrowBlueLeft16 = null;
        #endregion
        #region Image ArrowBlueLeft24
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku arrow-blue-left-24.png.
        /// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
        /// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
        /// Případně je možno vyvolat metodu ArrowBlueLeft24_Reset(), která zajistí regenerování obrázku z jeho definice.
        /// Bezpečnější je používání property ArrowBlueLeft24, která vrací vždy nový objekt.
        /// Pro používání pro Button.Image, kde bude nastavováno Button.Enabled = false; je třeba použít property ArrowBlueLeft24_FromFile.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\DavidPrac\VSProjects\ReportEditor\Reporting.Green\Pics\source\arrow-blue-left-24.png
        /// </remarks>
        public static System.Drawing.Image ArrowBlueLeft24_Cached
        {
            get
            {
                if (_ArrowBlueLeft24 == null) _ArrowBlueLeft24 = ArrowBlueLeft24;
                return _ArrowBlueLeft24;
            }
        }
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku arrow-blue-left-24.png.
        /// Nelze používat jako Image pro Buttony, kde bude nastavováno Enabled = false (pak dojde k chybě .NET: Ot of memory).
        /// Pak je třeba použít Image ArrowBlueLeft24_FromFile.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití ArrowBlueLeft24_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property ArrowBlueLeft24_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\DavidPrac\VSProjects\ReportEditor\Reporting.Green\Pics\source\arrow-blue-left-24.png
        /// </remarks>
        public static System.Drawing.Image ArrowBlueLeft24 { get { return _ImageCreateFrom(_ArrowBlueLeft24_string, null); } }
        /// <summary>
        /// Vrátí obrázek, načtený ze souboru arrow-blue-left-24.png.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití ArrowBlueLeft24_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property ArrowBlueLeft24_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\DavidPrac\VSProjects\ReportEditor\Reporting.Green\Pics\source\arrow-blue-left-24.png
        /// </remarks>
        public static System.Drawing.Image ArrowBlueLeft24_FromFile { get { return _ImageCreateFrom(_ArrowBlueLeft24_string, "arrow-blue-left-24.png"); } }
        /// <summary>
        /// Vygeneruje a vrátí string, který definuje obsah souboru ArrowBlueLeft24
        /// </summary>
        /// <returns></returns>
        private static string _ArrowBlueLeft24_string()
        {
            System.Text.StringBuilder sb = new System.Text.StringBuilder(1208);
            sb.Append("iVBORw0KGgoAAAANSUhEUgAAAAwAAAAYCAYAAADOMhxqAAAABGdBTUEAAK/INwWK6QAAAAlwSFlzAAAOwwAADsMBx2+oZAAAAA10RVh0U291cmNlAE51dm9sYaxPNfEA");
            sb.Append("AAAadEVYdFNvZnR3YXJlAFBhaW50Lk5FVCB2My41LjExR/NCNwAAAutJREFUOE+tkmtIk2EYhp9tOk/L4SHLDLQi0ZzKPM7MQ5rnUvLUkqkEWT/ykBmKgkpUWOkPifKU");
            sb.Append("00lO5gHUUvAYaioiuCxETXNoHko0wsh0Tvf0qh8i0qIfXfD9eZ/r5nu43xf+Px6vAHhVAA5lAPbF1KEqzneDxok8AOtKFliVGgC3kEFNVGAnAnCSGLO9a57oXxBX0x1K");
            sb.Append("eNTkAG71ALalZAWxoZ6XJEeQ0//jYsabNTUnYQJlHMCS7Got0tVyrUwPy+pebhj/jrH5UjmDV5FCGftwqACwKtdkOolu+SS3L1QNf8P66S0MezwsZ5wVHwicKdreW0PN");
            sb.Append("TnjV9Wbzp4KeBRSNKfF+5090TupbprlIBJRJ4JQAcMV0sH0RaBNVP5zb+hmfSpWY1LSObunD64d860uBV22yKzuSjjlCGnCK3E+H1vRl1k4oHw1sYWTlBtqnjW7q+DbW");
            sb.Append("gbPEAgZx1ycBGlgXcY8HVbUnlY1sZnUp0LNAgebJkwqdgOYOcJHYgWcjDVzrqIB1ob6uu6g4Nn9Ikd4hR04e4uGEL6gZ0CIlsgecq6WBB6l6D85z0vfLipDckS3HfAVq");
            sb.Append("3UXUvrGA2kFtgwyPBnJZpLmAAUrexraITncQurD8G3uPxk9tGWVuol7qBnJSpjaMI7sawavNEpHsHzK0FyCfkA7OlX5al9qlJinzaJytxFPZG2iTKpOzw/vLwf+tGQSP");
            sb.Append("UIFt7IQArjVqZNcIVnjvR9OM5Z2QGQmZJspWmeFD+RAsNaJsCp6YvNAmbbpPaxw7+t3cyawVNLmHaJi6hswY2VcI/cCnzH14NQFcaGPRg3rSDK6PL5k/+LXzJ2bcohwi");
            sb.Append("x/7wlrbxbiGt9OozLg89PBI/s2KRs456Scty4E+qCPh1Avh3k1akx9T5o8+M7yyuGt5eWqcJphMpQwWBpPuIMTP1aFkB89rsa1rMrDs1UUHYe9DkVgNckbGBP20E0fPq");
            sb.Append("1OQv8CcAoqaAJpgBiJmjDv8ZgN8wXSq4BYTrygAAAABJRU5ErkJggg==");
            return sb.ToString();
        }
        /// <summary>
        /// Resetuje obrázek v paměti.
        /// Následující použití property ArrowBlueLeft24_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
        /// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
        /// </summary>
        public static void ArrowBlueLeft24_Reset()
        {
            _ArrowBlueLeft24 = null;
        }
        /// <summary>
        /// Úložiště objektu v paměti, při prvním použití ArrowBlueLeft24_Direct je objekt naplněn a následně využíván.
        /// </summary>
        private static System.Drawing.Image _ArrowBlueLeft24 = null;
        #endregion
        #region Image ArrowBlueLeft32
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku arrow-blue-left-32.png.
        /// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
        /// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
        /// Případně je možno vyvolat metodu ArrowBlueLeft32_Reset(), která zajistí regenerování obrázku z jeho definice.
        /// Bezpečnější je používání property ArrowBlueLeft32, která vrací vždy nový objekt.
        /// Pro používání pro Button.Image, kde bude nastavováno Button.Enabled = false; je třeba použít property ArrowBlueLeft32_FromFile.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\DavidPrac\VSProjects\ReportEditor\Reporting.Green\Pics\source\arrow-blue-left-32.png
        /// </remarks>
        public static System.Drawing.Image ArrowBlueLeft32_Cached
        {
            get
            {
                if (_ArrowBlueLeft32 == null) _ArrowBlueLeft32 = ArrowBlueLeft32;
                return _ArrowBlueLeft32;
            }
        }
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku arrow-blue-left-32.png.
        /// Nelze používat jako Image pro Buttony, kde bude nastavováno Enabled = false (pak dojde k chybě .NET: Ot of memory).
        /// Pak je třeba použít Image ArrowBlueLeft32_FromFile.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití ArrowBlueLeft32_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property ArrowBlueLeft32_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\DavidPrac\VSProjects\ReportEditor\Reporting.Green\Pics\source\arrow-blue-left-32.png
        /// </remarks>
        public static System.Drawing.Image ArrowBlueLeft32 { get { return _ImageCreateFrom(_ArrowBlueLeft32_string, null); } }
        /// <summary>
        /// Vrátí obrázek, načtený ze souboru arrow-blue-left-32.png.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití ArrowBlueLeft32_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property ArrowBlueLeft32_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\DavidPrac\VSProjects\ReportEditor\Reporting.Green\Pics\source\arrow-blue-left-32.png
        /// </remarks>
        public static System.Drawing.Image ArrowBlueLeft32_FromFile { get { return _ImageCreateFrom(_ArrowBlueLeft32_string, "arrow-blue-left-32.png"); } }
        /// <summary>
        /// Vygeneruje a vrátí string, který definuje obsah souboru ArrowBlueLeft32
        /// </summary>
        /// <returns></returns>
        private static string _ArrowBlueLeft32_string()
        {
            System.Text.StringBuilder sb = new System.Text.StringBuilder(1620);
            sb.Append("iVBORw0KGgoAAAANSUhEUgAAABAAAAAgCAYAAAAbifjMAAAABGdBTUEAAK/INwWK6QAAAAlwSFlzAAAOwwAADsMBx2+oZAAAAA10RVh0U291cmNlAE51dm9sYaxPNfEA");
            sb.Append("AAAadEVYdFNvZnR3YXJlAFBhaW50Lk5FVCB2My41LjExR/NCNwAABCFJREFUSEvVlGtQlFUYx/8L7iIBIlo0OiQ1OENpcXFdIBZwQUDugtyH22gyTXdDkJxpgKJwnGYa");
            sb.Append("xyzjEssdZAVChlsEacHIgGLFrVgWWTVoSASXSpDL01k6H4gh3G9Nv5n3y/s8v/+c9zzvOfgfsq8aeLEE2JsH7PmMv9QV9zrAu0EfzuWmkOSLsDeXF3TB9SKTm4RwrkyE");
            sb.Append("Q2EbxDnpEH9uxquPwKceCPhKD5Ky2G1+ivHQ9Mtk6l74K+xyZLxjHVwvAPFdAjiUBZu4laozynqpdnCSzP0qNLDPC+Jd/0LsVeClHwCHEg9D56KBVz/pou77D6mgZ4q2");
            sb.Append("+io0EBcE8s41cK0AtqQDjsXiDRJ5d+R7V6hjYpYaxonOdkzTVv8qDSTF6wTYszE5Fu/UE+c3eSc1LzaPaujiKFFuH9H7zZNk6lszDadyP969CnE+k4ssBHZ5ldLEuqXa");
            sb.Append("oSkqVxFlthNltD4gp7evkr5L5TdwUVhxYwWOBexHKTaDbW72C1FVs6U3JqhkmOhYE9Gb9fPklHydhK6VSkgV7vCsE3CLI/kCcCo0gU1OpmVA+YNPL9+i8hGiw9VEkaXz");
            sb.Append("5HCyn4SyqluQVkYh5GsB3L/kohZHOeBWYgDb7BPmnkX3sy4pqXR4icLLiGTnl8gmVUkij5opJr/MRCFk7Jf+B05yEZOPmLrJJ5MLe6lMtUj+BUTWWYtklTRKIs/aaSan");
            sb.Append("wqN2I2Q1XFqJXbaNgWNef+K561SinKcD+URmJ4meTJ4mA5/Gh5BeOM0OkhHcqriwGtvzYkOpXPWK/GdKqFki4xNEoiQio9fvkb5X4xzcqtPg1WiAA61cWI041xDivOOb");
            sb.Append("vBQzTyeNkEUmDzm2QNZJN8k8uHkCsoZEBLRuQEA7l1YiztGOzwiSwlMir0t/WKaO0Y4P2AqS2T5ksv3IGqFNQW1j8GoNR1C7HkK6uLgSBzYJlwozSCvOGQa2zFu9e5cs");
            sb.Append("WYgxC9n94Ty5pKnIMOi7Afi2e+OJGS6txoWdgX0129mjMAnvWLDOnFleiXEK0a6sBdp1XEnCg509ONi9B6G9XFqNqwLYX/+sYH9jy+a4Hnru1J/LISapRM9kzNLmo8ol");
            sb.Append("BN+oQ+iPT3FjDaTsHvBusRf4tHU+fnSAnv9obvlztCGi134nRAxMIazPh3evgWcjkPAT4Petu15Ax+C2N26S7ccLf+9J0iwJopUaRAyuc5y1+F8Bwq4JENgZon+oZ3RH");
            sb.Append("yjjZnVkki7RZ0otVaRA19IgALdqZR3yvj+CeI8LI/omdafdo9+k5EiaoNYge0SFAy6FrLKRPhLD+tzbGq6a2p9wl4eHbvyFWvZ936EAouxujhh5D9PA7gpjRLsTdPoP4");
            sb.Append("X8x5VUcih4A4tRAx6i2IvWOI2BFe0JWIfiCGSTFqFnSHXfdjvPDfAfwF/Pjkz+jvppkAAAAASUVORK5CYII=");
            return sb.ToString();
        }
        /// <summary>
        /// Resetuje obrázek v paměti.
        /// Následující použití property ArrowBlueLeft32_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
        /// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
        /// </summary>
        public static void ArrowBlueLeft32_Reset()
        {
            _ArrowBlueLeft32 = null;
        }
        /// <summary>
        /// Úložiště objektu v paměti, při prvním použití ArrowBlueLeft32_Direct je objekt naplněn a následně využíván.
        /// </summary>
        private static System.Drawing.Image _ArrowBlueLeft32 = null;
        #endregion
        #region Image ArrowBlueRight16
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku arrow-blue-right-16.png.
        /// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
        /// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
        /// Případně je možno vyvolat metodu ArrowBlueRight16_Reset(), která zajistí regenerování obrázku z jeho definice.
        /// Bezpečnější je používání property ArrowBlueRight16, která vrací vždy nový objekt.
        /// Pro používání pro Button.Image, kde bude nastavováno Button.Enabled = false; je třeba použít property ArrowBlueRight16_FromFile.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\DavidPrac\VSProjects\ReportEditor\Reporting.Green\Pics\source\arrow-blue-right-16.png
        /// </remarks>
        public static System.Drawing.Image ArrowBlueRight16_Cached
        {
            get
            {
                if (_ArrowBlueRight16 == null) _ArrowBlueRight16 = ArrowBlueRight16;
                return _ArrowBlueRight16;
            }
        }
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku arrow-blue-right-16.png.
        /// Nelze používat jako Image pro Buttony, kde bude nastavováno Enabled = false (pak dojde k chybě .NET: Ot of memory).
        /// Pak je třeba použít Image ArrowBlueRight16_FromFile.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití ArrowBlueRight16_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property ArrowBlueRight16_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\DavidPrac\VSProjects\ReportEditor\Reporting.Green\Pics\source\arrow-blue-right-16.png
        /// </remarks>
        public static System.Drawing.Image ArrowBlueRight16 { get { return _ImageCreateFrom(_ArrowBlueRight16_string, null); } }
        /// <summary>
        /// Vrátí obrázek, načtený ze souboru arrow-blue-right-16.png.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití ArrowBlueRight16_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property ArrowBlueRight16_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\DavidPrac\VSProjects\ReportEditor\Reporting.Green\Pics\source\arrow-blue-right-16.png
        /// </remarks>
        public static System.Drawing.Image ArrowBlueRight16_FromFile { get { return _ImageCreateFrom(_ArrowBlueRight16_string, "arrow-blue-right-16.png"); } }
        /// <summary>
        /// Vygeneruje a vrátí string, který definuje obsah souboru ArrowBlueRight16
        /// </summary>
        /// <returns></returns>
        private static string _ArrowBlueRight16_string()
        {
            System.Text.StringBuilder sb = new System.Text.StringBuilder(824);
            sb.Append("iVBORw0KGgoAAAANSUhEUgAAAAgAAAAQCAYAAAArij59AAAABGdBTUEAAK/INwWK6QAAAAlwSFlzAAAOwwAADsMBx2+oZAAAAA10RVh0U291cmNlAE51dm9sYaxPNfEA");
            sb.Append("AAAadEVYdFNvZnR3YXJlAFBhaW50Lk5FVCB2My41LjExR/NCNwAAAc1JREFUKFN9kV9MzXEYxj9xSAznAhmVmTOGi5YZtuiPipNi5RwnIbPKxlUzG202rGyHzawbY8Ma");
            sb.Append("V6zlIuE4aY5Sc85ki3L6+SX5s+WMC2Nlx6rHlxs35uJz9T7vu+d9HiT9F5zulpfJRa3DrG/JIDcI7i7IuQsZl2DtNdhwqCN+szOm1OJgL5kBF+4nUBCC1VdgWQOsrOoc");
            sb.Append("ez4mXW0b0cyChz3kh5yUvoB1TbD0PMwrbf98sv2bgjGp/tYHOfIfhygMz2FnH6xpBDbdq07ZH56obI7rRlQ6dv292Nx9m5L+RPJajSDnPmwM1C6s7FP25XE1RKTqi+/E");
            sb.Append("lmeNlL+dbgQBg3GfF6pLqrCVdkY6/WhS3gsfRWn0FGyPQOFTHEVdtXMP2JPUSK5zUtbZmBy+AT8UR0go7D6cfsSacNWNK7lOml8TEzteNVE+lGQEYd/ig9Efy+t/apE5");
            sb.Append("n3L8ixK80Qf4BmexrROmeHpHnEdHleaXlpz4qqk+K0KZvcAAueaLhPLXY7+HK+q/y7Hb6meXlcqeYeOrA7KaYXbVUHyVf1Qz9tk2noH0P5seE1Ke+Sz7Dkzba9mJFW8+");
            sb.Append("4bUy8VlQNgglPaYPk8/WNv5Z8V/EL41b+nGni6CdAAAAAElFTkSuQmCC");
            return sb.ToString();
        }
        /// <summary>
        /// Resetuje obrázek v paměti.
        /// Následující použití property ArrowBlueRight16_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
        /// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
        /// </summary>
        public static void ArrowBlueRight16_Reset()
        {
            _ArrowBlueRight16 = null;
        }
        /// <summary>
        /// Úložiště objektu v paměti, při prvním použití ArrowBlueRight16_Direct je objekt naplněn a následně využíván.
        /// </summary>
        private static System.Drawing.Image _ArrowBlueRight16 = null;
        #endregion
        #region Image ArrowBlueRight24
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku arrow-blue-right-24.png.
        /// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
        /// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
        /// Případně je možno vyvolat metodu ArrowBlueRight24_Reset(), která zajistí regenerování obrázku z jeho definice.
        /// Bezpečnější je používání property ArrowBlueRight24, která vrací vždy nový objekt.
        /// Pro používání pro Button.Image, kde bude nastavováno Button.Enabled = false; je třeba použít property ArrowBlueRight24_FromFile.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\DavidPrac\VSProjects\ReportEditor\Reporting.Green\Pics\source\arrow-blue-right-24.png
        /// </remarks>
        public static System.Drawing.Image ArrowBlueRight24_Cached
        {
            get
            {
                if (_ArrowBlueRight24 == null) _ArrowBlueRight24 = ArrowBlueRight24;
                return _ArrowBlueRight24;
            }
        }
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku arrow-blue-right-24.png.
        /// Nelze používat jako Image pro Buttony, kde bude nastavováno Enabled = false (pak dojde k chybě .NET: Ot of memory).
        /// Pak je třeba použít Image ArrowBlueRight24_FromFile.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití ArrowBlueRight24_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property ArrowBlueRight24_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\DavidPrac\VSProjects\ReportEditor\Reporting.Green\Pics\source\arrow-blue-right-24.png
        /// </remarks>
        public static System.Drawing.Image ArrowBlueRight24 { get { return _ImageCreateFrom(_ArrowBlueRight24_string, null); } }
        /// <summary>
        /// Vrátí obrázek, načtený ze souboru arrow-blue-right-24.png.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití ArrowBlueRight24_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property ArrowBlueRight24_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\DavidPrac\VSProjects\ReportEditor\Reporting.Green\Pics\source\arrow-blue-right-24.png
        /// </remarks>
        public static System.Drawing.Image ArrowBlueRight24_FromFile { get { return _ImageCreateFrom(_ArrowBlueRight24_string, "arrow-blue-right-24.png"); } }
        /// <summary>
        /// Vygeneruje a vrátí string, který definuje obsah souboru ArrowBlueRight24
        /// </summary>
        /// <returns></returns>
        private static string _ArrowBlueRight24_string()
        {
            System.Text.StringBuilder sb = new System.Text.StringBuilder(1252);
            sb.Append("iVBORw0KGgoAAAANSUhEUgAAAAwAAAAYCAYAAADOMhxqAAAABGdBTUEAAK/INwWK6QAAAAlwSFlzAAAOwwAADsMBx2+oZAAAAA10RVh0U291cmNlAE51dm9sYaxPNfEA");
            sb.Append("AAAadEVYdFNvZnR3YXJlAFBhaW50Lk5FVCB2My41LjExR/NCNwAAAw5JREFUOE+tkntI01EUx89P5yPfZrVhmWsiFNHDit6pmZmiuTnd1FlKplhGhYnaw1dKD4gikbA3");
            sb.Append("ERVJWC5ZGqKTdKRNRTPd/MlcrQeRaBrMLNtO135XiIr+iD5wOJff+XzvhcMP/o2g+1wFPiBVTT/+je01AGvvOUNA5SxYWcmDNUo6+BUF7RurXJzClDl8ca3SPqQmGlZU");
            sb.Append("8SCwlg5/ZjPt66qE8xPq1VkVfbhur0YLm1RbYb3KBkIbqTBNLsP19fdFvjvUzTc0I1j28K1lYUrzE9hUtwY2P2IgUsM5P8imgQ1K0dykppYzTaNYa/iGhXdMFp9EjQpC");
            sb.Append("1Esgu51zfnCIBgJrBJ7SxqrU62+sZVoL3u6axP2XX04IEltvQWizH7OdhMSdRMzhfAhR8WxCH0cLU5+ximvDmN+AeKn1C6aUGc0ecdoLsOUpHyK7iDgdCFKRV2rtmbCG");
            sb.Append("3T5p3a/CysdwTzXi2aYJFJ8aHHOK7SyFqE4vkPTQwGuy92Cyxq2NrraRLdmCdN37gNNmlN9CLKkbx+CiwQ+Osp4cEnCjCUqYGiC8xYOJbjvpnm4c9y6YxIiriIeVZlye");
            sb.Append("axwEaW8kNSkRz0igzcVB2l7okmo0z8iaRK9jiOEXP+PSI6Y3EKeTUJMQReRtbTMcpR0Ziw4OmIRHzOiWhzi38Ct6Zr4bsU9ii0Gm8+RksZZsSsOzk7TLF2Sy/ctKPqEg");
            sb.Append("H3FeMXnhwHuzbSJ7jtzOJwHOh2itLSPWbpm5S9ftnz+KggLE+SXfkH9oaIKXNHCTyD4gJRsKOE8DknY+E/f8ruu+IcucfCsKSy3onTv81WGn4QG5dTG8Q4D4/p8CMR0i");
            sb.Append("JkHX4po1jqITVvQ9+tHqmGJQg7x/NSSZGEgzct6qCvprxHSJ7Hawzb5F4+hX9MnqnGrUgkwfBHIDA/EDnDPFsis0ENsjdEgeaPLJG0L3DNMLiGclIGd5pLj5NP7lNCDr");
            sb.Append("dbNV9Bc6JBvqbRJZBchY+9/kKdyP0oNCT0J6V4jVk9Wxdn+Up5h9nB7kfWQLemASiDhV/w+A73bbRzukt8q8AAAAAElFTkSuQmCC");
            return sb.ToString();
        }
        /// <summary>
        /// Resetuje obrázek v paměti.
        /// Následující použití property ArrowBlueRight24_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
        /// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
        /// </summary>
        public static void ArrowBlueRight24_Reset()
        {
            _ArrowBlueRight24 = null;
        }
        /// <summary>
        /// Úložiště objektu v paměti, při prvním použití ArrowBlueRight24_Direct je objekt naplněn a následně využíván.
        /// </summary>
        private static System.Drawing.Image _ArrowBlueRight24 = null;
        #endregion
        #region Image ArrowBlueRight32
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku arrow-blue-right-32.png.
        /// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
        /// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
        /// Případně je možno vyvolat metodu ArrowBlueRight32_Reset(), která zajistí regenerování obrázku z jeho definice.
        /// Bezpečnější je používání property ArrowBlueRight32, která vrací vždy nový objekt.
        /// Pro používání pro Button.Image, kde bude nastavováno Button.Enabled = false; je třeba použít property ArrowBlueRight32_FromFile.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\DavidPrac\VSProjects\ReportEditor\Reporting.Green\Pics\source\arrow-blue-right-32.png
        /// </remarks>
        public static System.Drawing.Image ArrowBlueRight32_Cached
        {
            get
            {
                if (_ArrowBlueRight32 == null) _ArrowBlueRight32 = ArrowBlueRight32;
                return _ArrowBlueRight32;
            }
        }
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku arrow-blue-right-32.png.
        /// Nelze používat jako Image pro Buttony, kde bude nastavováno Enabled = false (pak dojde k chybě .NET: Ot of memory).
        /// Pak je třeba použít Image ArrowBlueRight32_FromFile.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití ArrowBlueRight32_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property ArrowBlueRight32_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\DavidPrac\VSProjects\ReportEditor\Reporting.Green\Pics\source\arrow-blue-right-32.png
        /// </remarks>
        public static System.Drawing.Image ArrowBlueRight32 { get { return _ImageCreateFrom(_ArrowBlueRight32_string, null); } }
        /// <summary>
        /// Vrátí obrázek, načtený ze souboru arrow-blue-right-32.png.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití ArrowBlueRight32_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property ArrowBlueRight32_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\DavidPrac\VSProjects\ReportEditor\Reporting.Green\Pics\source\arrow-blue-right-32.png
        /// </remarks>
        public static System.Drawing.Image ArrowBlueRight32_FromFile { get { return _ImageCreateFrom(_ArrowBlueRight32_string, "arrow-blue-right-32.png"); } }
        /// <summary>
        /// Vygeneruje a vrátí string, který definuje obsah souboru ArrowBlueRight32
        /// </summary>
        /// <returns></returns>
        private static string _ArrowBlueRight32_string()
        {
            System.Text.StringBuilder sb = new System.Text.StringBuilder(1572);
            sb.Append("iVBORw0KGgoAAAANSUhEUgAAABAAAAAgCAYAAAAbifjMAAAABGdBTUEAAK/INwWK6QAAAAlwSFlzAAAOwwAADsMBx2+oZAAAAA10RVh0U291cmNlAE51dm9sYaxPNfEA");
            sb.Append("AAAadEVYdFNvZnR3YXJlAFBhaW50Lk5FVCB2My41LjExR/NCNwAAA/1JREFUSEvNkGtMk2cUx08LLaMgDEdm5pQxEyXDRLJkG8nGTahAKVBaCi0FHE5JdknUCWN4GTo2");
            sb.Append("2abRfTCLl7FkJtMlZiLhsgkURDEgvBa03FosAoYpEztgoghC/3vYHjLCUPGbv+R8ec//95xzXnqGCP2FVRFRCKuwYv7xafhXlrLypLAiZ4oo5Y2FEsrE0KLPKORMDYUU");
            sb.Append("v0/yUilFnOXNhRB0+m1PZVm/4UsTlmsqByioJIOiK5wotpoHnsQ7Reu81RX2spYhHDjVA09FxQ0K+01LSTViUpzjoccRXCz3Ulfaj9WP4OrAJLKOWCGLrrJQeJWcDLUi");
            sb.Append("SmngwUcRUiL30hjtB+tGUNoDNN6YQPq+dkgiq5sp8txbtKqKSNXIw/MRWhbukWC8s6diCN+3AT93AEbrGJR5rQ5x1HkjKer8KKaeh+cj4ldf8bqzxsAcM3bXPED+BeC4");
            sb.Append("GSgx30Nwttkhir54muIafChO4MJcVNUiklcES6KM1sDtFmwpn8TmcqCwGTjReBcBH5nHSXGpkBKEF0jTwqXZKCqJ0htEFGnUSpTne9/M64XuxCTSTwE/tACHqofh+97V");
            sb.Append("MVIKBewBD9K2cnE20Uai2AsSiqrdJFXV29fsuom1RxxQHQeOmRzYW2LHkvXmvyi+ZQfp256j5E4uziamlii+3oUUF7OlGmFoRe4g/L5yQH4UOMoe2XZyEJ6p7X+SujWT");
            sb.Append("dJ0u3JpDTB1R3CU3im0okOrME0s+vQev7UDwd8BhYQobC2/DJaXTSkmdr3NjDir2p9WClOKadjhpzQ/ct4xC+jEg+wTQ/ORAxo9DcE2z9lKSJZAbs1BfJtKanEnZtOHF");
            sb.Append("9CsDfrm3Idk6BTcmL8sHfHaOwD3DNkrJlhzSW2Xc4miaiRJNYooVNB76ln7l/gH45TsgywaWfwH45o3CJb37Plt9HxmuubMHuDiDfzm7XQiXaZvbgvJ/x+q9k3Dj8orP");
            sb.Append("70O24fpDNvkw6bsWk26unMBWjxcCJBqT4J/TB/+C/+RVBeNYlNk3yeRiJi9jxaXZJFx+mdWZ5zfZHK/uGYd7DpPZza99MwGvD/ohSrbUsJX9/z95BrVpLWnNg5IP72IR");
            sb.Append("k33Y5NX7H8J7802IdFaBdF1vsD4Pz4emWU7J7Xa3rWP/yGsOTuGlbX9ArLNamSynjbdE868+g+aKXKzvtC/dNYaAbx14JfcOnA1dfWzlRErrEZGhmwcfRaJZ7myw2P2/");
            sb.Append("HsPK3cOQpNoG2eRMWn/difTXeOhxaNuDnVOtt5ZmDcD13e5hJmdRarcLpdp44Ekkd3iTznJApO9qYrfuJIPNjVIWMnmGxDZi97qyyYtJb5M+nTyNrmP6AVbsT0/fnNbD");
            sb.Append("G882RH8DkNz6mBzmkIYAAAAASUVORK5CYII=");
            return sb.ToString();
        }
        /// <summary>
        /// Resetuje obrázek v paměti.
        /// Následující použití property ArrowBlueRight32_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
        /// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
        /// </summary>
        public static void ArrowBlueRight32_Reset()
        {
            _ArrowBlueRight32 = null;
        }
        /// <summary>
        /// Úložiště objektu v paměti, při prvním použití ArrowBlueRight32_Direct je objekt naplněn a následně využíván.
        /// </summary>
        private static System.Drawing.Image _ArrowBlueRight32 = null;
        #endregion
        #region Image ArrowBlueUp16
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku arrow-blue-up-16.png.
        /// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
        /// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
        /// Případně je možno vyvolat metodu ArrowBlueUp16_Reset(), která zajistí regenerování obrázku z jeho definice.
        /// Bezpečnější je používání property ArrowBlueUp16, která vrací vždy nový objekt.
        /// Pro používání pro Button.Image, kde bude nastavováno Button.Enabled = false; je třeba použít property ArrowBlueUp16_FromFile.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\DavidPrac\VSProjects\ReportEditor\Reporting.Green\Pics\source\arrow-blue-up-16.png
        /// </remarks>
        public static System.Drawing.Image ArrowBlueUp16_Cached
        {
            get
            {
                if (_ArrowBlueUp16 == null) _ArrowBlueUp16 = ArrowBlueUp16;
                return _ArrowBlueUp16;
            }
        }
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku arrow-blue-up-16.png.
        /// Nelze používat jako Image pro Buttony, kde bude nastavováno Enabled = false (pak dojde k chybě .NET: Ot of memory).
        /// Pak je třeba použít Image ArrowBlueUp16_FromFile.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití ArrowBlueUp16_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property ArrowBlueUp16_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\DavidPrac\VSProjects\ReportEditor\Reporting.Green\Pics\source\arrow-blue-up-16.png
        /// </remarks>
        public static System.Drawing.Image ArrowBlueUp16 { get { return _ImageCreateFrom(_ArrowBlueUp16_string, null); } }
        /// <summary>
        /// Vrátí obrázek, načtený ze souboru arrow-blue-up-16.png.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití ArrowBlueUp16_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property ArrowBlueUp16_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\DavidPrac\VSProjects\ReportEditor\Reporting.Green\Pics\source\arrow-blue-up-16.png
        /// </remarks>
        public static System.Drawing.Image ArrowBlueUp16_FromFile { get { return _ImageCreateFrom(_ArrowBlueUp16_string, "arrow-blue-up-16.png"); } }
        /// <summary>
        /// Vygeneruje a vrátí string, který definuje obsah souboru ArrowBlueUp16
        /// </summary>
        /// <returns></returns>
        private static string _ArrowBlueUp16_string()
        {
            System.Text.StringBuilder sb = new System.Text.StringBuilder(832);
            sb.Append("iVBORw0KGgoAAAANSUhEUgAAABAAAAAICAYAAADwdn+XAAAABGdBTUEAAK/INwWK6QAAAAlwSFlzAAAOwwAADsMBx2+oZAAAAA10RVh0U291cmNlAE51dm9sYaxPNfEA");
            sb.Append("AAAadEVYdFNvZnR3YXJlAFBhaW50Lk5FVCB2My41LjExR/NCNwAAAdFJREFUKFNNkF9I03EUxc9vU4cYyIhCDaOGGhiZGyltGtXcGP6HyAjNB2PgS5lYKCj04BpBhiAj");
            sb.Append("9aGUKKdOc0WNMVRsP19ac5mlP5BIg0qQ6CEkNJudvhnoHs69XC73c+89IAnoe4EMl4Qj9yTo+4D8AcAwHIf8kSvqQu8NFAU0sPiBon/ySaKWUBz8P7sdcruB7B7geD9w");
            sb.Append("chTIGZKQ43aVt4ZZ0PKWKHj+EJaJBJRMA7YpwDqxnXcBeY/FVjdgGhN5NBHHBh/VOiN0ylvM7iT32hVK5sAYiuVkVMwA5WGgMhIDMD0BjCNi2KNRnfD4rrresfvNH+pu");
            sb.Append("i+Y1MvUWeaBhmaoS+SVKX2lROQtUKTEAozhbP5iqMXrktgeLHPpAmu9vMal6nntq3lPXHmW6gKU3f6W6IhRB2UwGzi/EAPKGs/af8Ya6vEucXCXtT38xrU78ftp/N94a");
            sb.Append("cBgaFWY6Nnm4g8y6+Y2aqrk5nJvX7wD22Z4tuIMrVKKkQ/7JQ5fDhOmFA7ZJwDwOlTXYfLBeiWpb1qm7Qx51rjGhZnF5B6At9X08ez3029DweiPlovwDp/xNQsJpAbCM");
            sb.Append("C9eF+2Uhu/qC8l116dN6cv3nzfjapS8k8Re40vNbhWEonwAAAABJRU5ErkJggg==");
            return sb.ToString();
        }
        /// <summary>
        /// Resetuje obrázek v paměti.
        /// Následující použití property ArrowBlueUp16_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
        /// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
        /// </summary>
        public static void ArrowBlueUp16_Reset()
        {
            _ArrowBlueUp16 = null;
        }
        /// <summary>
        /// Úložiště objektu v paměti, při prvním použití ArrowBlueUp16_Direct je objekt naplněn a následně využíván.
        /// </summary>
        private static System.Drawing.Image _ArrowBlueUp16 = null;
        #endregion
        #region Image ArrowBlueUp24
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku arrow-blue-up-24.png.
        /// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
        /// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
        /// Případně je možno vyvolat metodu ArrowBlueUp24_Reset(), která zajistí regenerování obrázku z jeho definice.
        /// Bezpečnější je používání property ArrowBlueUp24, která vrací vždy nový objekt.
        /// Pro používání pro Button.Image, kde bude nastavováno Button.Enabled = false; je třeba použít property ArrowBlueUp24_FromFile.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\DavidPrac\VSProjects\ReportEditor\Reporting.Green\Pics\source\arrow-blue-up-24.png
        /// </remarks>
        public static System.Drawing.Image ArrowBlueUp24_Cached
        {
            get
            {
                if (_ArrowBlueUp24 == null) _ArrowBlueUp24 = ArrowBlueUp24;
                return _ArrowBlueUp24;
            }
        }
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku arrow-blue-up-24.png.
        /// Nelze používat jako Image pro Buttony, kde bude nastavováno Enabled = false (pak dojde k chybě .NET: Ot of memory).
        /// Pak je třeba použít Image ArrowBlueUp24_FromFile.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití ArrowBlueUp24_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property ArrowBlueUp24_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\DavidPrac\VSProjects\ReportEditor\Reporting.Green\Pics\source\arrow-blue-up-24.png
        /// </remarks>
        public static System.Drawing.Image ArrowBlueUp24 { get { return _ImageCreateFrom(_ArrowBlueUp24_string, null); } }
        /// <summary>
        /// Vrátí obrázek, načtený ze souboru arrow-blue-up-24.png.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití ArrowBlueUp24_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property ArrowBlueUp24_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\DavidPrac\VSProjects\ReportEditor\Reporting.Green\Pics\source\arrow-blue-up-24.png
        /// </remarks>
        public static System.Drawing.Image ArrowBlueUp24_FromFile { get { return _ImageCreateFrom(_ArrowBlueUp24_string, "arrow-blue-up-24.png"); } }
        /// <summary>
        /// Vygeneruje a vrátí string, který definuje obsah souboru ArrowBlueUp24
        /// </summary>
        /// <returns></returns>
        private static string _ArrowBlueUp24_string()
        {
            System.Text.StringBuilder sb = new System.Text.StringBuilder(1336);
            sb.Append("iVBORw0KGgoAAAANSUhEUgAAABgAAAAMCAYAAAB4MH11AAAABGdBTUEAAK/INwWK6QAAAAlwSFlzAAAOwwAADsMBx2+oZAAAAA10RVh0U291cmNlAE51dm9sYaxPNfEA");
            sb.Append("AAAadEVYdFNvZnR3YXJlAFBhaW50Lk5FVCB2My41LjExR/NCNwAAA0xJREFUOE+NlHlIVFEUxr83T8fMTM3UNilGJ2jPIqvRydFRZ6xJcy0qE6eMKCoKyjaNLNqg/KPN");
            sb.Append("iAijIhuzcRlxKbXFcTRr0nJcmhYiSFrRNq3sdK1XTNH2g8N9D777ncN55zz8YMyRb6fTLh799/Jw38fDM5PDlGxAlsvifF/I8uQI1IdgRr4zgovBTkCh5xCYxyNAz0NW");
            sb.Append("yENyGgiv/Ob1E7JjgF8WMOEoMJE9TzoOTD0JBJwHpuW6iIP1y0cnX24alWJss1eVrIfC4M6pKphZGRDGIrwc6H2PuAzMrhZM/4biAktyDpic4+ag0G8MWGV8nKp7ShEH");
            sb.Append("X5Jrovkpr7q4AyGlXlDVApoa4dL/omRVjz0D+OuG9QvN36PeWPcyo+gVRWcTeaUTDd30mgZoLZ285sphqKp8oWSVR9ULl//FdB2LE6w9upGeswxZc7ebO/Zfek0LzzLj");
            sb.Append("tI/UZ80HctlA5J3+njyWWd+KY+pOYZZxPGbWcIg2CyZ/wp+1xCebY20ZPyjSkLM08867YzXvaEUh0aQ9b8hV29rttKila2jqGxqURjRiWzcNXv2o2yH+pgGaOn/MrhUh");
            sb.Append("5rZg9iu95uNO86xyuSSupGzD8dZPZ8xdlF5JpD7UQUMWNz4XqSsy+2iqdo9ZaWmfkNH5NYlkx0fyXtfe47ig6Sqib4UjymyP+BbB1Bb/czwvzwvzS750da/u/qfiux/o");
            sb.Append("QP1nSsx+RcNTzE/s1BVpUJZ5QFnl5jTHuEayvPmhdEsHeaV9Jt+dPSTZ/KLHWWu9ziVYohHfbC+42uB31t0z0pC3NstCOTc66WDNW1p2qp18U+ofisLKVzFzV4SyUQyt");
            sb.Append("YmNZ3c8+qlY7cHFLa/+VL8hlXRdJMrrIO/UZOSRaSxHb7Cm42jAt19lJXbR1ZFJl9eil1SbfJUaTx9wrxcx8PoJKHBFcKggZqmts3k1ibs7NSFGCJV8032oSJz0wOWof");
            sb.Append("GPmF1t1IaHMRlDZEFPVupitk+T4IKJBCbpBCUTIMYeVihLBFimCj+J3IWnAaE1jP7RDTMASxjVLENklZ730wr20AFtzjBKUN4YVAEFv9wAJAzpIFsV+BklWtuigIfkNs");
            sb.Append("A4tGII5NTlwTkMA+7rw2sASCAPgCLONQhs7KFdAAAAAASUVORK5CYII=");
            return sb.ToString();
        }
        /// <summary>
        /// Resetuje obrázek v paměti.
        /// Následující použití property ArrowBlueUp24_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
        /// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
        /// </summary>
        public static void ArrowBlueUp24_Reset()
        {
            _ArrowBlueUp24 = null;
        }
        /// <summary>
        /// Úložiště objektu v paměti, při prvním použití ArrowBlueUp24_Direct je objekt naplněn a následně využíván.
        /// </summary>
        private static System.Drawing.Image _ArrowBlueUp24 = null;
        #endregion
        #region Image ArrowBlueUp32
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku arrow-blue-up-32.png.
        /// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
        /// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
        /// Případně je možno vyvolat metodu ArrowBlueUp32_Reset(), která zajistí regenerování obrázku z jeho definice.
        /// Bezpečnější je používání property ArrowBlueUp32, která vrací vždy nový objekt.
        /// Pro používání pro Button.Image, kde bude nastavováno Button.Enabled = false; je třeba použít property ArrowBlueUp32_FromFile.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\DavidPrac\VSProjects\ReportEditor\Reporting.Green\Pics\source\arrow-blue-up-32.png
        /// </remarks>
        public static System.Drawing.Image ArrowBlueUp32_Cached
        {
            get
            {
                if (_ArrowBlueUp32 == null) _ArrowBlueUp32 = ArrowBlueUp32;
                return _ArrowBlueUp32;
            }
        }
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku arrow-blue-up-32.png.
        /// Nelze používat jako Image pro Buttony, kde bude nastavováno Enabled = false (pak dojde k chybě .NET: Ot of memory).
        /// Pak je třeba použít Image ArrowBlueUp32_FromFile.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití ArrowBlueUp32_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property ArrowBlueUp32_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\DavidPrac\VSProjects\ReportEditor\Reporting.Green\Pics\source\arrow-blue-up-32.png
        /// </remarks>
        public static System.Drawing.Image ArrowBlueUp32 { get { return _ImageCreateFrom(_ArrowBlueUp32_string, null); } }
        /// <summary>
        /// Vrátí obrázek, načtený ze souboru arrow-blue-up-32.png.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití ArrowBlueUp32_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property ArrowBlueUp32_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\DavidPrac\VSProjects\ReportEditor\Reporting.Green\Pics\source\arrow-blue-up-32.png
        /// </remarks>
        public static System.Drawing.Image ArrowBlueUp32_FromFile { get { return _ImageCreateFrom(_ArrowBlueUp32_string, "arrow-blue-up-32.png"); } }
        /// <summary>
        /// Vygeneruje a vrátí string, který definuje obsah souboru ArrowBlueUp32
        /// </summary>
        /// <returns></returns>
        private static string _ArrowBlueUp32_string()
        {
            System.Text.StringBuilder sb = new System.Text.StringBuilder(1704);
            sb.Append("iVBORw0KGgoAAAANSUhEUgAAACAAAAAQCAYAAAB3AH1ZAAAABGdBTUEAAK/INwWK6QAAAAlwSFlzAAAOwwAADsMBx2+oZAAAAA10RVh0U291cmNlAE51dm9sYaxPNfEA");
            sb.Append("AAAadEVYdFNvZnR3YXJlAFBhaW50Lk5FVCB2My41LjExR/NCNwAABF9JREFUSEvNlXtM1WUYx78IHIGDt7loSZrM0f0yTQzlcjgI5/BDOnK4HC66nNGm1dRMzVuzjNLS");
            sb.Append("2Nr6o3RgTStXcrhHylUOAYIiyVVuOpimgzntSGriOd+eA4etFeay/uizPdvZfu/7fp73Pc/7vPgLz+8D5jpiPzAvE5h/AFjwJbDwILDoq9ExYblAeL4rQnP9EJrvj/BC");
            sb.Append("d0T8MPot8AgQeVTiGKArBfRlEhVA1HEg2jI65p7MF3mAyBeI/AWRB4rcEQ4ccn2+G4Jzkt20BbWqiKJGhBWuhu6Yx4jQgU4S0JWMyqPKAaVS5FWj3+4bXT6gEbk21wtB");
            sb.Append("Oau8dYU/J+5qYUJGNz1jyq4ivHirJDAZehHGVDsn/Zc45Ivz1Fhk3jI1qmjw1c+6mNk4zNRvbZz5Zj9VMZVWRJR8KDueDuXf7vaPhOVAduw4eh+R73nIeHRoy8Fz/KLJ");
            sb.Append("RiWLnLKFnJVu58xNl+hhrL0FXXmmHLcfltQAhhPORe6XCBEvNAMhOb4iz5pjKrm5N/8CDzXbGXOAnCpy9/Wk91vk7A/s9Hv7Cr1MJ4ehWPIkgUehPwXENTkX+6doRB6Q");
            sb.Append("LXLzUwgyHwl45fidrMoBHmohTV+Tj+0mH9z8K9XrrtPtDTvVmxxJkP47rZzyUosdMbXlePFEIMj7SCIiD1grVycoO2BCsLk8+HWLLbvhKr9pJVdmk5rP7fTfNkCP+BN3");
            sb.Append("3JbWDc/ecJmzdtg5aeQkyCd23eC0tA66GBoasfTkYphOT0Biq3Pxe+HYubHIBYuy9e4hOU3G7fUsabvOw23kumIy6bCN8965SA9D9RAiSz+V/3z3jJS6a4aMS3w83UZv");
            sb.Append("50k8vecWfV47xwnG090wNplganWFqd0puRtaR4PJdZVmYlSH53WmfdTEmt4bNHeS71nItd/bGJTeR09DlVR8aTqiKqZiSbUauqoND6TUD4S+f5H+ksTkzaSfJPFsxjB9");
            sb.Append("11+gW2JLP+KaVyKp3QPJXU7ZeGhFHmJOna4U9m3PbGfz5dssPk/uO0OmVw1Ts7OHquiKQZFvRHSllyQw2t0MdSooNS+rExr6ntvWz0feHeZkKVBHEnM/sdFv6wBVqWcH");
            sb.Append("YOpYIwm4O23jEJozRaI8Jf0Uq85e53ctN7n/9E3usQxRs6OdE5XyPpGnQanwHGk4Yyg/ArEN7oipj5uY0Ng2ffV5qtbc4KSNtzlr520+s/c3zpA6cUnqrEdS1zTnrHHQ");
            sb.Append("5HogLO9jn7hjg7OXV1p9l1VZfZdbrD7Jll9c9WUnRb4UsRbXkfb6Zwz1wKoeF8Q2hsL4U6WLqeOaS3KX1XVZj3Xiil6rakXvFaR0ZyK5R+2cMQ4hUoDaAh+E5IcjuEBB");
            sb.Append("aJECTbEC7dEoabNPSk8fXz5GrNz71F4g/swcxDfrkdCiIKFNQWKHgqTOSEngYaT2OwffDW2BdD0JTZH8LpailFcuQl62kVftb+RjOO58/BmJZiBBrl6iVL7pLEaKL6Vb");
            sb.Append("4rxz4P8C4HeXChQe/QNYRAAAAABJRU5ErkJggg==");
            return sb.ToString();
        }
        /// <summary>
        /// Resetuje obrázek v paměti.
        /// Následující použití property ArrowBlueUp32_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
        /// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
        /// </summary>
        public static void ArrowBlueUp32_Reset()
        {
            _ArrowBlueUp32 = null;
        }
        /// <summary>
        /// Úložiště objektu v paměti, při prvním použití ArrowBlueUp32_Direct je objekt naplněn a následně využíván.
        /// </summary>
        private static System.Drawing.Image _ArrowBlueUp32 = null;
        #endregion
        #region Image ArrowRedDown16
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku arrow-red-down-16.png.
        /// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
        /// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
        /// Případně je možno vyvolat metodu ArrowRedDown16_Reset(), která zajistí regenerování obrázku z jeho definice.
        /// Bezpečnější je používání property ArrowRedDown16, která vrací vždy nový objekt.
        /// Pro používání pro Button.Image, kde bude nastavováno Button.Enabled = false; je třeba použít property ArrowRedDown16_FromFile.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\DavidPrac\VSProjects\ReportEditor\Reporting.Green\Pics\source\arrow-red-down-16.png
        /// </remarks>
        public static System.Drawing.Image ArrowRedDown16_Cached
        {
            get
            {
                if (_ArrowRedDown16 == null) _ArrowRedDown16 = ArrowRedDown16;
                return _ArrowRedDown16;
            }
        }
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku arrow-red-down-16.png.
        /// Nelze používat jako Image pro Buttony, kde bude nastavováno Enabled = false (pak dojde k chybě .NET: Ot of memory).
        /// Pak je třeba použít Image ArrowRedDown16_FromFile.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití ArrowRedDown16_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property ArrowRedDown16_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\DavidPrac\VSProjects\ReportEditor\Reporting.Green\Pics\source\arrow-red-down-16.png
        /// </remarks>
        public static System.Drawing.Image ArrowRedDown16 { get { return _ImageCreateFrom(_ArrowRedDown16_string, null); } }
        /// <summary>
        /// Vrátí obrázek, načtený ze souboru arrow-red-down-16.png.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití ArrowRedDown16_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property ArrowRedDown16_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\DavidPrac\VSProjects\ReportEditor\Reporting.Green\Pics\source\arrow-red-down-16.png
        /// </remarks>
        public static System.Drawing.Image ArrowRedDown16_FromFile { get { return _ImageCreateFrom(_ArrowRedDown16_string, "arrow-red-down-16.png"); } }
        /// <summary>
        /// Vygeneruje a vrátí string, který definuje obsah souboru ArrowRedDown16
        /// </summary>
        /// <returns></returns>
        private static string _ArrowRedDown16_string()
        {
            System.Text.StringBuilder sb = new System.Text.StringBuilder(828);
            sb.Append("iVBORw0KGgoAAAANSUhEUgAAABAAAAAICAYAAADwdn+XAAAABGdBTUEAAK/INwWK6QAAAAlwSFlzAAAOwgAADsIBFShKgAAAAA10RVh0U291cmNlAE51dm9sYaxPNfEA");
            sb.Append("AAAadEVYdFNvZnR3YXJlAFBhaW50Lk5FVCB2My41LjExR/NCNwAAAc5JREFUKFNV0U9IFFEcB/DfqYhAOnVbZ+aNGymYzp83s+OqaS6uhVEYhJ4q6BJdg/YWeclToXaI");
            sb.Append("LhKdNLLDXhRULKxDspot21J6WKlgl5h135v+rbr9/DmHhQ7v8R78vp/fj/cAEWGptzWbuXG5un4l8XvtnPFjzVFv5rkG25YGRVODEmdQstlV39aLFVOvynjrruCnvhxm");
            sb.Append("Q2BlwCr4c2msfSqgfDSBnwe8Wj6mpULApjBnt8pJ74/sbkfZ34XBxSQK53SxDiy7ipEZ8jbKs9O4v7KKQeoufu13sMC10aITTVVGLtSCS31hWA4mULjNm8Jk8Trw2lHh");
            sb.Append("XYfSlO1pzpSfTuLeqzQG10awFGtBv7vtnxzsRdnnoUx2oeDRnLBZGwFhNtwWbQUyhOS4emLL05fF+BhWp55Rx06kQpQ9DspEB4Wb3tM9UjEY+LTqwEuuQDrWCOuWCt9t");
            sb.Append("reGbp80G91P4d3Ic5XnqftZGYenz4ox+smwxKNDK0fvUgRma4GFnBJ67EVggzHfZ0R2PTf26cxt/Xh/GHZe9EO3seJ5+5IOpwltbhQ06/wc8JmAiHoEnhBwW0JhHKha7");
            sb.Append("J5zoAwofyxoqLJkKvDEUWOUqfAwBhANk5AFtICMaUAAAAABJRU5ErkJggg==");
            return sb.ToString();
        }
        /// <summary>
        /// Resetuje obrázek v paměti.
        /// Následující použití property ArrowRedDown16_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
        /// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
        /// </summary>
        public static void ArrowRedDown16_Reset()
        {
            _ArrowRedDown16 = null;
        }
        /// <summary>
        /// Úložiště objektu v paměti, při prvním použití ArrowRedDown16_Direct je objekt naplněn a následně využíván.
        /// </summary>
        private static System.Drawing.Image _ArrowRedDown16 = null;
        #endregion
        #region Image ArrowRedDown24
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku arrow-red-down-24.png.
        /// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
        /// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
        /// Případně je možno vyvolat metodu ArrowRedDown24_Reset(), která zajistí regenerování obrázku z jeho definice.
        /// Bezpečnější je používání property ArrowRedDown24, která vrací vždy nový objekt.
        /// Pro používání pro Button.Image, kde bude nastavováno Button.Enabled = false; je třeba použít property ArrowRedDown24_FromFile.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\DavidPrac\VSProjects\ReportEditor\Reporting.Green\Pics\source\arrow-red-down-24.png
        /// </remarks>
        public static System.Drawing.Image ArrowRedDown24_Cached
        {
            get
            {
                if (_ArrowRedDown24 == null) _ArrowRedDown24 = ArrowRedDown24;
                return _ArrowRedDown24;
            }
        }
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku arrow-red-down-24.png.
        /// Nelze používat jako Image pro Buttony, kde bude nastavováno Enabled = false (pak dojde k chybě .NET: Ot of memory).
        /// Pak je třeba použít Image ArrowRedDown24_FromFile.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití ArrowRedDown24_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property ArrowRedDown24_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\DavidPrac\VSProjects\ReportEditor\Reporting.Green\Pics\source\arrow-red-down-24.png
        /// </remarks>
        public static System.Drawing.Image ArrowRedDown24 { get { return _ImageCreateFrom(_ArrowRedDown24_string, null); } }
        /// <summary>
        /// Vrátí obrázek, načtený ze souboru arrow-red-down-24.png.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití ArrowRedDown24_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property ArrowRedDown24_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\DavidPrac\VSProjects\ReportEditor\Reporting.Green\Pics\source\arrow-red-down-24.png
        /// </remarks>
        public static System.Drawing.Image ArrowRedDown24_FromFile { get { return _ImageCreateFrom(_ArrowRedDown24_string, "arrow-red-down-24.png"); } }
        /// <summary>
        /// Vygeneruje a vrátí string, který definuje obsah souboru ArrowRedDown24
        /// </summary>
        /// <returns></returns>
        private static string _ArrowRedDown24_string()
        {
            System.Text.StringBuilder sb = new System.Text.StringBuilder(1308);
            sb.Append("iVBORw0KGgoAAAANSUhEUgAAABgAAAAMCAYAAAB4MH11AAAABGdBTUEAAK/INwWK6QAAAAlwSFlzAAAOwgAADsIBFShKgAAAAA10RVh0U291cmNlAE51dm9sYaxPNfEA");
            sb.Append("AAAadEVYdFNvZnR3YXJlAFBhaW50Lk5FVCB2My41LjExR/NCNwAAAzdJREFUOE91k2tIFFEUx++mVJBFUWBstXNn1lf53tk7u+5DTc1l2970/hIVGkEfKjM/VBYIRUEG");
            sb.Append("QRQlhpVkHyoqKgt7aKZkub0MNSIto9pd07njY7XQ25nMtdI+/DhnLof//9zLf5BWq/1FeTRGd0UOVRCMHhIOPYZaa8ToSSIOzPyLJ15AvgQBdSYKSAao4TdwNjwTaMrD");
            sb.Append("wIDgkAoTxg8kTqiWsAAmM2tEHPSa8KgpgQ/M1sfyyANCXw1CkM8ghIJBOAir8MAUCsbDs4GmXOIm3bNE5dYstDx45rI9cmeaq93JcZfribDYbcLjm8QRA49RQF+ShGCv");
            sb.Append("KKS3J+rLZIO+jpKIJ1SKqqTGsHwwmTw8O2Jg5WZUZ4rXWo4WMPnKZUZPFzHPnrzBZpf97RtJv7lR5EPeG2BzAptLwkSvFL66I9XwSrbGDlJLLFMcyUxZYGVgUiGLQugo");
            sb.Append("g7tmLrjKEr7k5eYVT72lZwe+V1az/pLzrGPXdtbqsHx4Z9TngMFUMAjxWOdmdyxKblaWpjEljbAuZypTnKmDij2+gYr69XCD8WMZoEd2LrhWwpkNqzOqvCePDfTfuM76");
            sb.Append("jhUyOXsD+5wuff0k6g96TJH5nascH5U1LqakS0ObO+xwi5inILycGoUJUAO6gUalysSh5yascZuxqXmR5ab38IH+vrKLzL9/H6OrFjOfLc7/zRbTSxfah8Qz1Zr0g5rm");
            sb.Append("3gfRFCDoT3GVvz5U6iCer2xY00hwbIuDXGjfm9PtLy5iPTu3MSUjiVHTPEatcdBbmZJC/PDmV0FUgncf96+4yqgDlZcQy4oNs1GLxOs/zY8/Ie/IVvwnjrOerZuYkiz+");
            sb.Append("MlJSxF5Kws+BaLSa+7HEVcY8VGlK5NFrC0afzXyozz6voCtrnbev8Ajr3rKRKbaEDkrCCkFUJ5v5/4qrBJreyCx0yahDxUSHTpE56AzUG0YOtULmZUmYTpOicrvWut53");
            sb.Append("rXS2URJ5QI1ip6hHDfCn1xgwqgPcwAuIcgMsN8rgkqRDJbZodGi5VrPbOUuT59RqBtsoKgXTdsg+pGMy4IJtlwHTOuGsUsTIA3/4LcJp7pg5zW27TtMqRqBG47CBFv0E");
            sb.Append("93iFGGikFo0AAAAASUVORK5CYII=");
            return sb.ToString();
        }
        /// <summary>
        /// Resetuje obrázek v paměti.
        /// Následující použití property ArrowRedDown24_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
        /// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
        /// </summary>
        public static void ArrowRedDown24_Reset()
        {
            _ArrowRedDown24 = null;
        }
        /// <summary>
        /// Úložiště objektu v paměti, při prvním použití ArrowRedDown24_Direct je objekt naplněn a následně využíván.
        /// </summary>
        private static System.Drawing.Image _ArrowRedDown24 = null;
        #endregion
        #region Image ArrowRedDown32
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku arrow-red-down-32.png.
        /// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
        /// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
        /// Případně je možno vyvolat metodu ArrowRedDown32_Reset(), která zajistí regenerování obrázku z jeho definice.
        /// Bezpečnější je používání property ArrowRedDown32, která vrací vždy nový objekt.
        /// Pro používání pro Button.Image, kde bude nastavováno Button.Enabled = false; je třeba použít property ArrowRedDown32_FromFile.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\DavidPrac\VSProjects\ReportEditor\Reporting.Green\Pics\source\arrow-red-down-32.png
        /// </remarks>
        public static System.Drawing.Image ArrowRedDown32_Cached
        {
            get
            {
                if (_ArrowRedDown32 == null) _ArrowRedDown32 = ArrowRedDown32;
                return _ArrowRedDown32;
            }
        }
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku arrow-red-down-32.png.
        /// Nelze používat jako Image pro Buttony, kde bude nastavováno Enabled = false (pak dojde k chybě .NET: Ot of memory).
        /// Pak je třeba použít Image ArrowRedDown32_FromFile.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití ArrowRedDown32_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property ArrowRedDown32_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\DavidPrac\VSProjects\ReportEditor\Reporting.Green\Pics\source\arrow-red-down-32.png
        /// </remarks>
        public static System.Drawing.Image ArrowRedDown32 { get { return _ImageCreateFrom(_ArrowRedDown32_string, null); } }
        /// <summary>
        /// Vrátí obrázek, načtený ze souboru arrow-red-down-32.png.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití ArrowRedDown32_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property ArrowRedDown32_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\DavidPrac\VSProjects\ReportEditor\Reporting.Green\Pics\source\arrow-red-down-32.png
        /// </remarks>
        public static System.Drawing.Image ArrowRedDown32_FromFile { get { return _ImageCreateFrom(_ArrowRedDown32_string, "arrow-red-down-32.png"); } }
        /// <summary>
        /// Vygeneruje a vrátí string, který definuje obsah souboru ArrowRedDown32
        /// </summary>
        /// <returns></returns>
        private static string _ArrowRedDown32_string()
        {
            System.Text.StringBuilder sb = new System.Text.StringBuilder(1636);
            sb.Append("iVBORw0KGgoAAAANSUhEUgAAACAAAAAQCAYAAAB3AH1ZAAAABGdBTUEAAK/INwWK6QAAAAlwSFlzAAAOwgAADsIBFShKgAAAAA10RVh0U291cmNlAE51dm9sYaxPNfEA");
            sb.Append("AAAadEVYdFNvZnR3YXJlAFBhaW50Lk5FVCB2My41LjExR/NCNwAABC1JREFUSEvFlWtMHFUUxy8pAavGJtZPqOzMbIFKWXbntQuUBYVtiSCGPk19JFSx0Zg2GjBqG9Ok");
            sb.Append("1X5oYnzUaAyNsYamiLHENH6wPAQRUp5FSwpoxMLWZnd57cyyW7qYHv8DhSwwVfvJD7/cuScz93fOmXtnWFJS0v/KqsB5iWONsoU1KxxrlSzsJ5ljHaBT5FifxK+63wy/");
            sb.Append("Q2ATICgBcQHt1vXKe5dNzkOMBNY1qFxOk8ptaVEtnjbF4mlXuIJOieN6qh5il8TbJ+F38CwgC0YCSUigEAk8AWkJ5EXAjesHjERin1k2+V62JDbI3NuteTZvR4E4eSHf");
            sb.Append("Ptnlzpzsyc0Y71aFhj6Fd19M5+MGTZLw2wUWKOOYXxLsSKJ+ShImgqI1rMnWGU1JCYJrSOA9JLA29rlli6D16xplruXyoQOktzSRVltL+uenKPjhCRp5pox+dm0YGlD4");
            sb.Append("XZcdfPxITCV+tNaXKcT5ZaFwXE3tnnY7KKimkpadQXphNoVKizBmEZLpQQL3xzqXLgyaJS7+B5V76UJptu/PmmqaGxymueYfaa6unsIffETeZ7fRoCvlyrDMV/zuEBLH");
            sb.Append("IJ6X24Q1fkXYHsh+ZEDbDllxHmk5NtK3uim0rYT0kgLSXOlBdOAQSIh1rkyAtYlcQruLK+8qsHnH3n+Xov39FD33Hd048TGFjx4h354yGnGlTo5IfNWoQ7jbJwkJkO8d");
            sb.Append("z7d79fLdpO8oghyVG/KyYtKL3KSpqROovBLye8Ey57KJQSt2fK+Nj+9SuJ19eelDY4crabajnebO1tP1d45Q+LX9NLGrmLxq6vRViT+Gd35wfKvqCx14gUI7b8m3bIYc");
            sb.Append("nXjMBXnKKOQvag7hLkP+rwkYdNo5dsW6Ma4fJ2HAZe31vvr8zdmmRorW1VHk9Uqa2fs0TRXnk9+ZNhdQN0S1skLSwZL8ScjzFOOdD0G+Q7MLa1aKFzENGvTizE9bs9ig");
            sb.Append("wjuHndbGqxW7b0bOfYskvqbwK/uwsTykFTjnpZqMDZe1CW3PpVCJh/RchyHvhtyjZVrjbic3MA0ucgnnus/Nsd9kPm1E4b/x7Sm+Ea45RdHar2im4jlUKaLFaQu73aj8");
            sb.Append("8UeNzfcXxE1ACRx9kKH1pmsvYhqMxTjzvyo8GxX5ZK/CnwyUumcj1Z9Q9MwZmil/inQnKvfkYLNh52dvMuT1qDgdo+mXbyWmQTOQAPM5hPUBVTg2XeTUrx/HCTl9msL7");
            sb.Append("X55vvebcGIH0U0iT/6vcwDRoBo4cu4aFp0ThvmlVOKjn2acih9+kyFtVpG/OmIH0OKTr70RuYBr8JyaxuGYTEoOysE9zpQ3jA/MHpG/gXd9zJ+JFVgXO4odUoySzavCZ");
            sb.Append("8jA7ifELNZl9ibFetMzfY4ggTIBYBC7M1xqVL67Rhg9aO+gAXfiL9oKLOFW/OLilexZIYn8D3ERmr2bKNFQAAAAASUVORK5CYII=");
            return sb.ToString();
        }
        /// <summary>
        /// Resetuje obrázek v paměti.
        /// Následující použití property ArrowRedDown32_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
        /// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
        /// </summary>
        public static void ArrowRedDown32_Reset()
        {
            _ArrowRedDown32 = null;
        }
        /// <summary>
        /// Úložiště objektu v paměti, při prvním použití ArrowRedDown32_Direct je objekt naplněn a následně využíván.
        /// </summary>
        private static System.Drawing.Image _ArrowRedDown32 = null;
        #endregion
        #region Image ArrowRedLeft16
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku arrow-red-left-16.png.
        /// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
        /// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
        /// Případně je možno vyvolat metodu ArrowRedLeft16_Reset(), která zajistí regenerování obrázku z jeho definice.
        /// Bezpečnější je používání property ArrowRedLeft16, která vrací vždy nový objekt.
        /// Pro používání pro Button.Image, kde bude nastavováno Button.Enabled = false; je třeba použít property ArrowRedLeft16_FromFile.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\DavidPrac\VSProjects\ReportEditor\Reporting.Green\Pics\source\arrow-red-left-16.png
        /// </remarks>
        public static System.Drawing.Image ArrowRedLeft16_Cached
        {
            get
            {
                if (_ArrowRedLeft16 == null) _ArrowRedLeft16 = ArrowRedLeft16;
                return _ArrowRedLeft16;
            }
        }
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku arrow-red-left-16.png.
        /// Nelze používat jako Image pro Buttony, kde bude nastavováno Enabled = false (pak dojde k chybě .NET: Ot of memory).
        /// Pak je třeba použít Image ArrowRedLeft16_FromFile.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití ArrowRedLeft16_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property ArrowRedLeft16_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\DavidPrac\VSProjects\ReportEditor\Reporting.Green\Pics\source\arrow-red-left-16.png
        /// </remarks>
        public static System.Drawing.Image ArrowRedLeft16 { get { return _ImageCreateFrom(_ArrowRedLeft16_string, null); } }
        /// <summary>
        /// Vrátí obrázek, načtený ze souboru arrow-red-left-16.png.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití ArrowRedLeft16_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property ArrowRedLeft16_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\DavidPrac\VSProjects\ReportEditor\Reporting.Green\Pics\source\arrow-red-left-16.png
        /// </remarks>
        public static System.Drawing.Image ArrowRedLeft16_FromFile { get { return _ImageCreateFrom(_ArrowRedLeft16_string, "arrow-red-left-16.png"); } }
        /// <summary>
        /// Vygeneruje a vrátí string, který definuje obsah souboru ArrowRedLeft16
        /// </summary>
        /// <returns></returns>
        private static string _ArrowRedLeft16_string()
        {
            System.Text.StringBuilder sb = new System.Text.StringBuilder(820);
            sb.Append("iVBORw0KGgoAAAANSUhEUgAAAAgAAAAQCAYAAAArij59AAAABGdBTUEAAK/INwWK6QAAAAlwSFlzAAAOwgAADsIBFShKgAAAAA10RVh0U291cmNlAE51dm9sYaxPNfEA");
            sb.Append("AAAadEVYdFNvZnR3YXJlAFBhaW50Lk5FVCB2My41LjExR/NCNwAAAclJREFUKFN9kU1rE2EUhe/fcPHOTBurNVZpZuZNJtNktI0fTYugoIJQXLiwFSmu1IVdunDpcvKh");
            sb.Append("ZtK0qbEgGilaS0yR1hZEBbGkUiWj2FCkCwNSsYvjNS7ciIuHA5dzD5dzCcB/oWJYaTEp/zAVUahktV0qHgohHWm/Rh4PPTbkLVbmtiNGKleHsZbLw0sEq5QxBaUtQZmo");
            sb.Append("oJQjhu4PDWx/X/mChjeBfCxQoawUlOXNdFwMlk73fdt8uoDtx4t4OzqCQlTLtQyuI8LjJ3vWGw9n8TMziY8Xz+FuvOPdhFRUcm1lz63B0KpfKOHHjZuon0ii5Oz2C2Gl");
            sb.Append("q2yqRHd697754KawdWUMn+39mJZt60WphIqmQrOSDd4RvVa/MIym1Y267MCDg11+Waq7qqZGz34npKQwp+x23z8cQ9M28enscTzpN9/PSXXnQkgjynIUd5GYiXVuNo4e");
            sb.Append("QNOJwj/Vj/l4cHlJ13ZwDwqNM9NSOTPfE9z6muxjUwRr0SCWDc0l1xCU4zbvMY+kev5lfB+ax5LYsLvxWtcqVDZUmtFVmjP4KOa5qV2uJSQ2BnqxIgNVWuJDWugavWBd");
            sb.Append("ZH0lA2M1qxOrRuD6P1/8F9AvS43z9J8oWWgAAAAASUVORK5CYII=");
            return sb.ToString();
        }
        /// <summary>
        /// Resetuje obrázek v paměti.
        /// Následující použití property ArrowRedLeft16_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
        /// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
        /// </summary>
        public static void ArrowRedLeft16_Reset()
        {
            _ArrowRedLeft16 = null;
        }
        /// <summary>
        /// Úložiště objektu v paměti, při prvním použití ArrowRedLeft16_Direct je objekt naplněn a následně využíván.
        /// </summary>
        private static System.Drawing.Image _ArrowRedLeft16 = null;
        #endregion
        #region Image ArrowRedLeft24
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku arrow-red-left-24.png.
        /// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
        /// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
        /// Případně je možno vyvolat metodu ArrowRedLeft24_Reset(), která zajistí regenerování obrázku z jeho definice.
        /// Bezpečnější je používání property ArrowRedLeft24, která vrací vždy nový objekt.
        /// Pro používání pro Button.Image, kde bude nastavováno Button.Enabled = false; je třeba použít property ArrowRedLeft24_FromFile.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\DavidPrac\VSProjects\ReportEditor\Reporting.Green\Pics\source\arrow-red-left-24.png
        /// </remarks>
        public static System.Drawing.Image ArrowRedLeft24_Cached
        {
            get
            {
                if (_ArrowRedLeft24 == null) _ArrowRedLeft24 = ArrowRedLeft24;
                return _ArrowRedLeft24;
            }
        }
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku arrow-red-left-24.png.
        /// Nelze používat jako Image pro Buttony, kde bude nastavováno Enabled = false (pak dojde k chybě .NET: Ot of memory).
        /// Pak je třeba použít Image ArrowRedLeft24_FromFile.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití ArrowRedLeft24_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property ArrowRedLeft24_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\DavidPrac\VSProjects\ReportEditor\Reporting.Green\Pics\source\arrow-red-left-24.png
        /// </remarks>
        public static System.Drawing.Image ArrowRedLeft24 { get { return _ImageCreateFrom(_ArrowRedLeft24_string, null); } }
        /// <summary>
        /// Vrátí obrázek, načtený ze souboru arrow-red-left-24.png.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití ArrowRedLeft24_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property ArrowRedLeft24_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\DavidPrac\VSProjects\ReportEditor\Reporting.Green\Pics\source\arrow-red-left-24.png
        /// </remarks>
        public static System.Drawing.Image ArrowRedLeft24_FromFile { get { return _ImageCreateFrom(_ArrowRedLeft24_string, "arrow-red-left-24.png"); } }
        /// <summary>
        /// Vygeneruje a vrátí string, který definuje obsah souboru ArrowRedLeft24
        /// </summary>
        /// <returns></returns>
        private static string _ArrowRedLeft24_string()
        {
            System.Text.StringBuilder sb = new System.Text.StringBuilder(1224);
            sb.Append("iVBORw0KGgoAAAANSUhEUgAAAAwAAAAYCAYAAADOMhxqAAAABGdBTUEAAK/INwWK6QAAAAlwSFlzAAAOwgAADsIBFShKgAAAAA10RVh0U291cmNlAE51dm9sYaxPNfEA");
            sb.Append("AAAadEVYdFNvZnR3YXJlAFBhaW50Lk5FVCB2My41LjExR/NCNwAAAvhJREFUOE+VkntIU1Ecx8+sKEIKKoIm99y7+VwmtHvvudu8tpnTNqRIAit70AuhsCf+Yf1ZFEFE");
            sb.Append("Br02debadCWp2NSCLUMrI9GhVuoqyqIXWKKTkbPH6WyivW5Rf3zOH4fvh9/v/M4PyOXy/0Ly8kfqeAgqCeUEKwf/Lnh0NCjOjAWXRCq6VEfNt/BwmmRwkgoBApcAF10x");
            sb.Append("JJ+oTE+5UooYrWTwKk+DMkQBpwYuuGxMOX734P5Ac8H2j+Ua5R5JwZpKgQoRznGkxR9qObDz/ZCnFXceLAzZBUXhb2E7Ig8UqVkVYmyBZ+fGN4PXruNxz23s27cr5ES/");
            sb.Append("CJZUGO57pk2nyGvcuubpa6cLh2rcePjsOdy6YfV7l8BsmgqXaCng0MGoUkRl160zdQ2UlOGQ3YUDR47gzm1rx2r0yWUuBGMi4fCMbSKUWQRKX52jv+svPvV1zGLDgX27");
            sb.Append("cdf6VZ/r0pKuViGYFEzcMfEPRJBZNFBdZRY8PUcPfw6ePoMDW/Lww9UZn9yiyuviIVvL0bJq8r6J3hE1z25ItnYUFX4aPVmMR3PM+FkGjxt0CT4SNlTztKyGoyPZyHGB");
            sb.Append("zNthWGLvLsj/MrIuBweExfiJRoWbxKT2Wo1SW745BrQKzHfBKsAoG6J1taLqTu9y9GXYgPCQXo37ck3jXhOqb0K0CmMM2nhmSgA2gYpy8NB0XZvoe5qpw4EMLR5alU4k");
            sb.Append("c6hFv+TiTZ5mOkiViBDGRlbhMgenk15zb6Uu9r9csWxCMutxr0kMtmniT5MKC6eEME4y3nqent2AFPn301JevTUbcMCYigcNHH6E4t+1s8z6n4Qw9WQajTwd7UXKoq50");
            sb.Append("9eBgtjFS6TlKCPk4iV0K4ybb2szT89pQ7LF+Ixr5sDILv9AvDfWwfxBusDTwkkr3eEbuQ3FnBzI1wQEDN9bHKvdKCpO0kEo+lmEeobjzfiHB3c8q9ZLBSe6rGeDKigMP");
            sb.Append("OWZuL8csfMwqZkgGf6SbVYAHROzjlMCvVnz/h39DDr4BwDVP8di7RAwAAAAASUVORK5CYII=");
            return sb.ToString();
        }
        /// <summary>
        /// Resetuje obrázek v paměti.
        /// Následující použití property ArrowRedLeft24_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
        /// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
        /// </summary>
        public static void ArrowRedLeft24_Reset()
        {
            _ArrowRedLeft24 = null;
        }
        /// <summary>
        /// Úložiště objektu v paměti, při prvním použití ArrowRedLeft24_Direct je objekt naplněn a následně využíván.
        /// </summary>
        private static System.Drawing.Image _ArrowRedLeft24 = null;
        #endregion
        #region Image ArrowRedLeft32
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku arrow-red-left-32.png.
        /// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
        /// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
        /// Případně je možno vyvolat metodu ArrowRedLeft32_Reset(), která zajistí regenerování obrázku z jeho definice.
        /// Bezpečnější je používání property ArrowRedLeft32, která vrací vždy nový objekt.
        /// Pro používání pro Button.Image, kde bude nastavováno Button.Enabled = false; je třeba použít property ArrowRedLeft32_FromFile.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\DavidPrac\VSProjects\ReportEditor\Reporting.Green\Pics\source\arrow-red-left-32.png
        /// </remarks>
        public static System.Drawing.Image ArrowRedLeft32_Cached
        {
            get
            {
                if (_ArrowRedLeft32 == null) _ArrowRedLeft32 = ArrowRedLeft32;
                return _ArrowRedLeft32;
            }
        }
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku arrow-red-left-32.png.
        /// Nelze používat jako Image pro Buttony, kde bude nastavováno Enabled = false (pak dojde k chybě .NET: Ot of memory).
        /// Pak je třeba použít Image ArrowRedLeft32_FromFile.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití ArrowRedLeft32_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property ArrowRedLeft32_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\DavidPrac\VSProjects\ReportEditor\Reporting.Green\Pics\source\arrow-red-left-32.png
        /// </remarks>
        public static System.Drawing.Image ArrowRedLeft32 { get { return _ImageCreateFrom(_ArrowRedLeft32_string, null); } }
        /// <summary>
        /// Vrátí obrázek, načtený ze souboru arrow-red-left-32.png.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití ArrowRedLeft32_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property ArrowRedLeft32_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\DavidPrac\VSProjects\ReportEditor\Reporting.Green\Pics\source\arrow-red-left-32.png
        /// </remarks>
        public static System.Drawing.Image ArrowRedLeft32_FromFile { get { return _ImageCreateFrom(_ArrowRedLeft32_string, "arrow-red-left-32.png"); } }
        /// <summary>
        /// Vygeneruje a vrátí string, který definuje obsah souboru ArrowRedLeft32
        /// </summary>
        /// <returns></returns>
        private static string _ArrowRedLeft32_string()
        {
            System.Text.StringBuilder sb = new System.Text.StringBuilder(1664);
            sb.Append("iVBORw0KGgoAAAANSUhEUgAAABAAAAAgCAYAAAAbifjMAAAABGdBTUEAAK/INwWK6QAAAAlwSFlzAAAOwgAADsIBFShKgAAAAA10RVh0U291cmNlAE51dm9sYaxPNfEA");
            sb.Append("AAAadEVYdFNvZnR3YXJlAFBhaW50Lk5FVCB2My41LjExR/NCNwAABEJJREFUSEulk3tMU1ccxw86dM4sC/tjf7D13HtbHhpK7X2V8mqhCMUHrLhHZsISwmY02YwuI44/");
            sb.Append("dMt0btlf2whxvAYUUUqBIDTBigyRweRlN+VRxRiVxU0EeVxFxG7+di4EJuMyNfvjk9OenM/3/M79nYMCAwP/F4qTz4Li5H9RzVGojMOoSMAoj4yKi5bjhEAhl55aeYzH");
            sb.Append("LxULeFUhp3r6ACfZzcVS/g4B7ygVcHMBjz/L41QBiov/Tf0GGjWE0yvKDTjdaRX+aPloF9hN2lsFIo5TFB6ngsWoLYTxOyZiW7l5/Y3enG9gtKkVHBZWKhJxqqI0T2sI");
            sb.Append("g7pD1KhMxBZ7TPBA5+f7Yab3GoxWu8AZp5NKRFWKoihTwVLoYNyrqEzAfEmkuvts1gcw7fGCr6UL7tjLoTp+g0SClw8g5clyUHEE7W7cmf7X5E894HOfBZ+zFoZzcqHG");
            sb.Append("pJ04LlKbFeViItt5/FqRATtdmdsejTW1gc/VBDO5R0D6Lgfa37WBw8CccQqUZolcStpl53BAoajKr3k76cFw3Unw1Z2CB18chnsHD0Fnug0qjZorlQKOP6Gn/BbJP5CL");
            sb.Append("QeQXCwyqQ46UqOnrZRVk5x/hfvY+kPbuhl+326DKqBly8PgddxjtV0Nu5YJcwmN0VIdX54uqfUeTuMnBI9/Dw/rTcH/vh3A3Yzv0v5EM1RGacSLvJKJ/FZFlbyGglMWr");
            sb.Append("iJxZag67c/HLwzBDzjy16z2YTN0Il7aaoTYiaILIn9Sy1PPye5j3Fn7ki1hXFKnp7zmQDdN1jXDv/QyQYvRw0yKCyxj80CFQXxNxrXyl551FAXki5kujQq56D+yHqaws");
            sb.Append("kCK1MCmEwm9kdInqmSoef0rewmr3Y7svCigU8BryRD92msLueq2xIFmiZkPGxFDw2izQkMjdrhepHe5w6rlmjl4aQF6X3IG1dhF/Rc47dTUxBqSkWJiMIpXYyHfYnQmN");
            sb.Append("Zu3vboF6q1lHrWjTz4UsBMjInTjO4oAKgco9aQz1DW0yg2Q1gRSthYltVvBmvAnN0aEDzQKVdGOPammADAlANTwVSKhqiQ77c3hLwj+VpFmhLy0RWo1BnnaO5rrJUZYE");
            sb.Append("yFSSL13PUetcIn26w6SDkZSk2RApMhxGN5mgN1b36BxPu7pYeq4MJUjbUANHsad4usNjZmHs9eS545CQW4ZQ8HDMeA9HJyvKMi6eQr9oGdTE0/FnRLXXazGQI2yZDRkh");
            sb.Append("3bnIqyUPzyz/nGWa9BRq19F+rTyddk7UXL9mJZ2xbYXRhCjo4zXSBe4JATJyzzt09MqfeTrTYwi6fXNzPIylko6IwVL/kyqYp530vIdlVp3n6D19kevGhzYa4bIYPOLl");
            sb.Append("mARFQYlOlkak5Bd6OSZ7gFd3XWKZbwc55hXFxctxgWeQl2X8vRz98iDPrOnXM8r3YDnOcwzqZ0kI+S6XyXiF/Fdc+CwoTj49gehvSwouvKXMIkoAAAAASUVORK5CYII=");
            return sb.ToString();
        }
        /// <summary>
        /// Resetuje obrázek v paměti.
        /// Následující použití property ArrowRedLeft32_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
        /// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
        /// </summary>
        public static void ArrowRedLeft32_Reset()
        {
            _ArrowRedLeft32 = null;
        }
        /// <summary>
        /// Úložiště objektu v paměti, při prvním použití ArrowRedLeft32_Direct je objekt naplněn a následně využíván.
        /// </summary>
        private static System.Drawing.Image _ArrowRedLeft32 = null;
        #endregion
        #region Image ArrowRedRight16
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku arrow-red-right-16.png.
        /// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
        /// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
        /// Případně je možno vyvolat metodu ArrowRedRight16_Reset(), která zajistí regenerování obrázku z jeho definice.
        /// Bezpečnější je používání property ArrowRedRight16, která vrací vždy nový objekt.
        /// Pro používání pro Button.Image, kde bude nastavováno Button.Enabled = false; je třeba použít property ArrowRedRight16_FromFile.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\DavidPrac\VSProjects\ReportEditor\Reporting.Green\Pics\source\arrow-red-right-16.png
        /// </remarks>
        public static System.Drawing.Image ArrowRedRight16_Cached
        {
            get
            {
                if (_ArrowRedRight16 == null) _ArrowRedRight16 = ArrowRedRight16;
                return _ArrowRedRight16;
            }
        }
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku arrow-red-right-16.png.
        /// Nelze používat jako Image pro Buttony, kde bude nastavováno Enabled = false (pak dojde k chybě .NET: Ot of memory).
        /// Pak je třeba použít Image ArrowRedRight16_FromFile.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití ArrowRedRight16_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property ArrowRedRight16_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\DavidPrac\VSProjects\ReportEditor\Reporting.Green\Pics\source\arrow-red-right-16.png
        /// </remarks>
        public static System.Drawing.Image ArrowRedRight16 { get { return _ImageCreateFrom(_ArrowRedRight16_string, null); } }
        /// <summary>
        /// Vrátí obrázek, načtený ze souboru arrow-red-right-16.png.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití ArrowRedRight16_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property ArrowRedRight16_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\DavidPrac\VSProjects\ReportEditor\Reporting.Green\Pics\source\arrow-red-right-16.png
        /// </remarks>
        public static System.Drawing.Image ArrowRedRight16_FromFile { get { return _ImageCreateFrom(_ArrowRedRight16_string, "arrow-red-right-16.png"); } }
        /// <summary>
        /// Vygeneruje a vrátí string, který definuje obsah souboru ArrowRedRight16
        /// </summary>
        /// <returns></returns>
        private static string _ArrowRedRight16_string()
        {
            System.Text.StringBuilder sb = new System.Text.StringBuilder(828);
            sb.Append("iVBORw0KGgoAAAANSUhEUgAAAAgAAAAQCAYAAAArij59AAAABGdBTUEAAK/INwWK6QAAAAlwSFlzAAAOwgAADsIBFShKgAAAAA10RVh0U291cmNlAE51dm9sYaxPNfEA");
            sb.Append("AAAadEVYdFNvZnR3YXJlAFBhaW50Lk5FVCB2My41LjExR/NCNwAAAdBJREFUKFN9UT1MU1EY/SaMMTFOTvLevTwNDJha3r237z0KaVNja0RDYuLP4kBcdDd0M2Fh86cu");
            sb.Append("BmOQEQhIeRIgoG2kDBLavraWBRMqiQohxPAGCGr9/OriYhhO7nDOPd93zgeIeCRgKtpemY6btUlbC84oHTKSQVrq8Fxo8NLUALJ9vYdbcy7O9oZKrqOffUeCBRK8cDRI");
            sb.Append("dTaT4Hpsv179jF8mRnEu0pYn8tSKYDBqafDIOQMwH7uws/v4Gf7KFbA2lMLFsJFdUuzkqslgWNKIaaXfzSWsup/sx5+v3+DGk0HMOPpkXrJj6aAO4NI819KShbhE/85t");
            sb.Append("/PFqBD8N9OOyrQ+vCd70V9DYfkHpA2W7Df1LXXjwNIUbD+5jQbKHsEQLvVcMMiEjWek+/3sv0IJ+IoqbfbewqIxByFGsrOL3yjcT9b2eKPrdCmsRgfkQG6+a/HjD4YZ3");
            sb.Append("2Tr4fjWGfsTGzYs2WfP5iuQn3pI7fBAt37bDAfSjYfwa70JPGSulDnaaAGlBKUpBvt8gt6/E0JNG1RO8ec3ksEg9jHVQD1Wn/XDnWhzLVut6UbBA4+eq4DBD6aYI4Mlz");
            sb.Append("6x+t1q2iyTo9IsuEZYJLJc3S+98T/wPCH6y7+KYD6dQYAAAAAElFTkSuQmCC");
            return sb.ToString();
        }
        /// <summary>
        /// Resetuje obrázek v paměti.
        /// Následující použití property ArrowRedRight16_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
        /// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
        /// </summary>
        public static void ArrowRedRight16_Reset()
        {
            _ArrowRedRight16 = null;
        }
        /// <summary>
        /// Úložiště objektu v paměti, při prvním použití ArrowRedRight16_Direct je objekt naplněn a následně využíván.
        /// </summary>
        private static System.Drawing.Image _ArrowRedRight16 = null;
        #endregion
        #region Image ArrowRedRight24
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku arrow-red-right-24.png.
        /// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
        /// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
        /// Případně je možno vyvolat metodu ArrowRedRight24_Reset(), která zajistí regenerování obrázku z jeho definice.
        /// Bezpečnější je používání property ArrowRedRight24, která vrací vždy nový objekt.
        /// Pro používání pro Button.Image, kde bude nastavováno Button.Enabled = false; je třeba použít property ArrowRedRight24_FromFile.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\DavidPrac\VSProjects\ReportEditor\Reporting.Green\Pics\source\arrow-red-right-24.png
        /// </remarks>
        public static System.Drawing.Image ArrowRedRight24_Cached
        {
            get
            {
                if (_ArrowRedRight24 == null) _ArrowRedRight24 = ArrowRedRight24;
                return _ArrowRedRight24;
            }
        }
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku arrow-red-right-24.png.
        /// Nelze používat jako Image pro Buttony, kde bude nastavováno Enabled = false (pak dojde k chybě .NET: Ot of memory).
        /// Pak je třeba použít Image ArrowRedRight24_FromFile.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití ArrowRedRight24_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property ArrowRedRight24_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\DavidPrac\VSProjects\ReportEditor\Reporting.Green\Pics\source\arrow-red-right-24.png
        /// </remarks>
        public static System.Drawing.Image ArrowRedRight24 { get { return _ImageCreateFrom(_ArrowRedRight24_string, null); } }
        /// <summary>
        /// Vrátí obrázek, načtený ze souboru arrow-red-right-24.png.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití ArrowRedRight24_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property ArrowRedRight24_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\DavidPrac\VSProjects\ReportEditor\Reporting.Green\Pics\source\arrow-red-right-24.png
        /// </remarks>
        public static System.Drawing.Image ArrowRedRight24_FromFile { get { return _ImageCreateFrom(_ArrowRedRight24_string, "arrow-red-right-24.png"); } }
        /// <summary>
        /// Vygeneruje a vrátí string, který definuje obsah souboru ArrowRedRight24
        /// </summary>
        /// <returns></returns>
        private static string _ArrowRedRight24_string()
        {
            System.Text.StringBuilder sb = new System.Text.StringBuilder(1280);
            sb.Append("iVBORw0KGgoAAAANSUhEUgAAAAwAAAAYCAYAAADOMhxqAAAABGdBTUEAAK/INwWK6QAAAAlwSFlzAAAOwgAADsIBFShKgAAAAA10RVh0U291cmNlAE51dm9sYaxPNfEA");
            sb.Append("AAAadEVYdFNvZnR3YXJlAFBhaW50Lk5FVCB2My41LjExR/NCNwAAAyJJREFUOE+VkltIFFEYx8fahCijKDBWds+Z1dzwls7OmXFndbfMTd3ChEyqlygRewiCyiIpDYwe");
            sb.Append("hBK6UHSnoouptVkPVqSpq9Ki69TmLSnthmZoK61ZoF9nL9Wm9dDD/8ww/H7f+b5zhlEqlf8V71LBIV90aqaSoGlQYLyLNQozNwX1nGuSatF1vVpRqVdPAz3JNfmFWwTN");
            sb.Append("rZK0BffSdFarFJFZblApqsl0aS3xC+WCGtdYpNoXR0qgfmuW3Sois1WPZtRMaa/QogzyvtwSkOZRhtQwVFUBb69dnKjLTqmvFpFYzaOgWh3+JezN8AtVHsEsNH46cx6+");
            sb.Append("PWmEvlNlE3WrE+8/EFFssyYmQAjzCXcIWvzQFFfZV7hncvzSFRiz3oXe0uLxhjRy9ZGAwm0CyzTzmNln8c9wV4cU9wU205Zh6PmweweMlx2FLzeuw8vi3W5bSuzJOgmF");
            sb.Append("toiBAh2OnkpwDWFz7en6/sG8zfC1+ACMXjgHXTvzXM3JS0uaCFpoJ9gn9GkrqIAYeiohj4lmV7uZDAytXwPundvBdeo4dOVt/Gg3aAuoMM8r/MwDWuExwfMbePZwR1Ls");
            sb.Append("2EiqHtzbtsJIWSl0brC8auXx6j+ERgEz9fQSbfrIog4p2j0sRsGoUQcj+VugJzv9XRths37DtHq9iGY3JWnznetS3wyuMYLLEAfDdJdeY/ywLC452MbhBV7YxtFW9Ehh");
            sb.Append("00fkPM80dg/mWGB0pQAjqRK8NnJumYQfpdVDqeAb2sbjmTaeXekwxcsfMldQWITP5iToTyHjz0jEZQqr7PTGj8Wr/EICDn3KsTf6pJgJl4mAK80Ib1LE785E7W1aNXps");
            sb.Append("6X6mnWN/C00c1rQlsI2DUgyMppvgfVrSpFPQ1rZzWOjk2aCOaNbLnU5Q+36NFirIfETD0KpkGMhYPtmRGGV3cNjkJGyQTPv2MJ6cJSqfYOcwfkYi6/rNEnQnxzllHZtF");
            sb.Append("QUUg7MkJg19oTcDz2nXhRU4h8qHMh2+SCRs8FfakaHmYbwbHMpahLYQ4eBxK4Vl/gz05ZPQLbfQEHDSyTsPI9DkVDMxfP/47SuYH1ipi4eqzrOIAAAAASUVORK5CYII=");
            return sb.ToString();
        }
        /// <summary>
        /// Resetuje obrázek v paměti.
        /// Následující použití property ArrowRedRight24_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
        /// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
        /// </summary>
        public static void ArrowRedRight24_Reset()
        {
            _ArrowRedRight24 = null;
        }
        /// <summary>
        /// Úložiště objektu v paměti, při prvním použití ArrowRedRight24_Direct je objekt naplněn a následně využíván.
        /// </summary>
        private static System.Drawing.Image _ArrowRedRight24 = null;
        #endregion
        #region Image ArrowRedRight32
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku arrow-red-right-32.png.
        /// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
        /// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
        /// Případně je možno vyvolat metodu ArrowRedRight32_Reset(), která zajistí regenerování obrázku z jeho definice.
        /// Bezpečnější je používání property ArrowRedRight32, která vrací vždy nový objekt.
        /// Pro používání pro Button.Image, kde bude nastavováno Button.Enabled = false; je třeba použít property ArrowRedRight32_FromFile.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\DavidPrac\VSProjects\ReportEditor\Reporting.Green\Pics\source\arrow-red-right-32.png
        /// </remarks>
        public static System.Drawing.Image ArrowRedRight32_Cached
        {
            get
            {
                if (_ArrowRedRight32 == null) _ArrowRedRight32 = ArrowRedRight32;
                return _ArrowRedRight32;
            }
        }
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku arrow-red-right-32.png.
        /// Nelze používat jako Image pro Buttony, kde bude nastavováno Enabled = false (pak dojde k chybě .NET: Ot of memory).
        /// Pak je třeba použít Image ArrowRedRight32_FromFile.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití ArrowRedRight32_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property ArrowRedRight32_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\DavidPrac\VSProjects\ReportEditor\Reporting.Green\Pics\source\arrow-red-right-32.png
        /// </remarks>
        public static System.Drawing.Image ArrowRedRight32 { get { return _ImageCreateFrom(_ArrowRedRight32_string, null); } }
        /// <summary>
        /// Vrátí obrázek, načtený ze souboru arrow-red-right-32.png.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití ArrowRedRight32_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property ArrowRedRight32_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\DavidPrac\VSProjects\ReportEditor\Reporting.Green\Pics\source\arrow-red-right-32.png
        /// </remarks>
        public static System.Drawing.Image ArrowRedRight32_FromFile { get { return _ImageCreateFrom(_ArrowRedRight32_string, "arrow-red-right-32.png"); } }
        /// <summary>
        /// Vygeneruje a vrátí string, který definuje obsah souboru ArrowRedRight32
        /// </summary>
        /// <returns></returns>
        private static string _ArrowRedRight32_string()
        {
            System.Text.StringBuilder sb = new System.Text.StringBuilder(1648);
            sb.Append("iVBORw0KGgoAAAANSUhEUgAAABAAAAAgCAYAAAAbifjMAAAABGdBTUEAAK/INwWK6QAAAAlwSFlzAAAOwgAADsIBFShKgAAAAA10RVh0U291cmNlAE51dm9sYaxPNfEA");
            sb.Append("AAAadEVYdFNvZnR3YXJlAFBhaW50Lk5FVCB2My41LjExR/NCNwAABDVJREFUSEulk2tMm1UYx1+2CeqMS6af0HHOu8IY0nV9b225tAQoa2A3cCPRqXGYYYw6zTKnyeYS");
            sb.Append("M8k+aIyL05h4STTzwmAIiFzGCtuAwqTQFsocRDdhUYFBBy2wcTE8Pq+OYxvK3OKHX/Lv6fn/n+c85z1cdHT0/yLs4t3ARIlIuFNIqRTDlUkkZNPtYOKWORJZVSqSFRX4");
            sb.Append("O3jjUjCBAauQw6ekmMYyhbxQoSeRVfJ/hzBRqpDkSov2N+ehV6B2i3Go3EB2V+vJ8roNtw9holSJyarJFHy+sw1w+cQnUJ2uvVqlkJ318XRZvUhDTMEwgW1bay063/Xi");
            sb.Append("Ypi91AuX3i+CWsv63hpct8fxEU0JfIhxASbKcePpNJ3P9/kXMNfQDNMeD3Qf3gd1yRpXvUIN1TlruGZhcSdMVCoko86sHb127AOYKymHuaoamGp1gPvVgnm7gbc3SCT+");
            sb.Append("bJjrZeJ7idAqhbe7ns6FwLHjMHP8Q5j9rgICjXZwFebPNxr4svMSjWmRQ7tg4rSWRvwgEXNdkqav+6lcmHz7CNwsOgKzJSUwXlUJnbuyZ5oM9LMWgT50IWioTFTrCNcU");
            sb.Append("RyNqJbLTbtT09z25HSb27YUbB/ZjSCmMfvUldGxLvdmikKMY8KDz1jxYgEqdQDi7QO85I5M950xxviv52TCxexdMvfQ8zBSfhOFPP4IOmxJoU+jBzo38vS6JDw1QOaMn");
            sb.Append("3DmBRjXK5DWHIXZsIMcCga1WmNzzDMx8exL+eLcIXGna606ZFrpEPmpRgEoDDqpJoivPi+So0xA3O5yuQCBVD5PPPgHTX38Dv7/1BrhN6/pcIhXCBjhwSA6BRjbL9GC7");
            sb.Append("opkeStKCX4mHgCERpl5+EYbfPACepPX9bpEaF5txOK06uqJZJgXtNnloIDcTxpR14MeQgDUFBjelgjc1cdIt0Nc9enp/iLkNzQ49XeZQ6OMX8GEN7H0OAnlW8JsSIYDG");
            sb.Append("YZsFekzxN7D1d7oF/gEMCB1iRdYaDj+UjDZzQs+Vgnzw77CBPxkro3nElgYXjQlzWPnjLpFf7RH/eRvMrLbukOnGVmOssy8vC/x5/5qvb86E3hTtn2iuQPOjCPMFBzyC");
            sb.Append("lPeYdfO+bLw69cxZKTC2dRP8bNGDW+IbseXHFiovCmgVaXq7QEcG1YElb8DKZhjfboPLFgnQ5OySeBn/DzGrMIEDtHaKvO/a3wMzQyA3B/qtRvDIa/vQbP1Fx0cEt74A");
            sb.Append("Ez+K1OqSNb6RDBNM5G2GqzYzdCmxA1h9x096PsIbproKE9ie1a3E+ka32WBwSwZ4jXEjWLnwoo5f3h2m8gJMdIrU7JE0g79aTdCTlDCO5v09Ah/l1S9tVmECH8bDbpF/");
            sb.Append("r0ta245nPeQV+JXd+KEEbw4HEx0yz+F578PKq70SH3knZhUmXGhQ7xgDOPXMOLiQjUsRdvFuCLt450RzfwEkVTquXKdOGQAAAABJRU5ErkJggg==");
            return sb.ToString();
        }
        /// <summary>
        /// Resetuje obrázek v paměti.
        /// Následující použití property ArrowRedRight32_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
        /// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
        /// </summary>
        public static void ArrowRedRight32_Reset()
        {
            _ArrowRedRight32 = null;
        }
        /// <summary>
        /// Úložiště objektu v paměti, při prvním použití ArrowRedRight32_Direct je objekt naplněn a následně využíván.
        /// </summary>
        private static System.Drawing.Image _ArrowRedRight32 = null;
        #endregion
        #region Image ArrowRedUp16
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku arrow-red-up-16.png.
        /// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
        /// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
        /// Případně je možno vyvolat metodu ArrowRedUp16_Reset(), která zajistí regenerování obrázku z jeho definice.
        /// Bezpečnější je používání property ArrowRedUp16, která vrací vždy nový objekt.
        /// Pro používání pro Button.Image, kde bude nastavováno Button.Enabled = false; je třeba použít property ArrowRedUp16_FromFile.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\DavidPrac\VSProjects\ReportEditor\Reporting.Green\Pics\source\arrow-red-up-16.png
        /// </remarks>
        public static System.Drawing.Image ArrowRedUp16_Cached
        {
            get
            {
                if (_ArrowRedUp16 == null) _ArrowRedUp16 = ArrowRedUp16;
                return _ArrowRedUp16;
            }
        }
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku arrow-red-up-16.png.
        /// Nelze používat jako Image pro Buttony, kde bude nastavováno Enabled = false (pak dojde k chybě .NET: Ot of memory).
        /// Pak je třeba použít Image ArrowRedUp16_FromFile.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití ArrowRedUp16_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property ArrowRedUp16_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\DavidPrac\VSProjects\ReportEditor\Reporting.Green\Pics\source\arrow-red-up-16.png
        /// </remarks>
        public static System.Drawing.Image ArrowRedUp16 { get { return _ImageCreateFrom(_ArrowRedUp16_string, null); } }
        /// <summary>
        /// Vrátí obrázek, načtený ze souboru arrow-red-up-16.png.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití ArrowRedUp16_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property ArrowRedUp16_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\DavidPrac\VSProjects\ReportEditor\Reporting.Green\Pics\source\arrow-red-up-16.png
        /// </remarks>
        public static System.Drawing.Image ArrowRedUp16_FromFile { get { return _ImageCreateFrom(_ArrowRedUp16_string, "arrow-red-up-16.png"); } }
        /// <summary>
        /// Vygeneruje a vrátí string, který definuje obsah souboru ArrowRedUp16
        /// </summary>
        /// <returns></returns>
        private static string _ArrowRedUp16_string()
        {
            System.Text.StringBuilder sb = new System.Text.StringBuilder(832);
            sb.Append("iVBORw0KGgoAAAANSUhEUgAAABAAAAAICAYAAADwdn+XAAAABGdBTUEAAK/INwWK6QAAAAlwSFlzAAAOwgAADsIBFShKgAAAAA10RVh0U291cmNlAE51dm9sYaxPNfEA");
            sb.Append("AAAadEVYdFNvZnR3YXJlAFBhaW50Lk5FVCB2My41LjExR/NCNwAAAdFJREFUKFNNz09IFFEcB/A3EEmn8Nhh3pt1lz0Ilbs7b2Z29p9ZMuCyEHQSoSCCLh0qRIiIDp4i");
            sb.Append("b5l/Lkbo4LpJVruWyBqh7ZK267YHE8QlhDpoRO3swUrx23ODxcP3Pd7h+/m9HwFARlSZDIZlaciUpTGNkglOyaRJj00Z9MZ00NWbUVlTOsDIYV75mSTeUjag1Lv1Y1gA");
            sb.Append("I4ZMngQpSQnADsnSRIQ+Wr51FYUrlzCj06dvODu+oCpkXiBz/P/dAMbFRFvkmcZISqcn7Ig8/vHeTewODaOWsFCK+pDRlOdi6smcn5H3AsqLNIAUF0VRThq0KRlSZssP");
            sb.Append("7uOPnYRjxVA92wInqmO900BWdb1b5ErzB1Fe9R8FDr9t0lNTUc/i+uOH2MvMw7ncg2KoFQWzFb+6YqidC2PzvIklzV3MccVTPApM6tQ7nfAtV+wx7OdLcO7cxYqlIc3Z");
            sb.Append("QEZ393/qieNnogO1CzFsxTuwEvSWCwHF1wBmrLa1b7MvcVD5jurgKHLxMF7otH9O7PtarJc1XH2lrtD+jtkGRyDbFy2Ude+XBpBuP13JX+/ey3fHf7/t5NW0zm6LkDqg");
            sb.Append("MrIgkCVVubbK3T8+B1p2NyJn/q5xz1cA5B9caPSyQ36fJwAAAABJRU5ErkJggg==");
            return sb.ToString();
        }
        /// <summary>
        /// Resetuje obrázek v paměti.
        /// Následující použití property ArrowRedUp16_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
        /// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
        /// </summary>
        public static void ArrowRedUp16_Reset()
        {
            _ArrowRedUp16 = null;
        }
        /// <summary>
        /// Úložiště objektu v paměti, při prvním použití ArrowRedUp16_Direct je objekt naplněn a následně využíván.
        /// </summary>
        private static System.Drawing.Image _ArrowRedUp16 = null;
        #endregion
        #region Image ArrowRedUp24
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku arrow-red-up-24.png.
        /// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
        /// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
        /// Případně je možno vyvolat metodu ArrowRedUp24_Reset(), která zajistí regenerování obrázku z jeho definice.
        /// Bezpečnější je používání property ArrowRedUp24, která vrací vždy nový objekt.
        /// Pro používání pro Button.Image, kde bude nastavováno Button.Enabled = false; je třeba použít property ArrowRedUp24_FromFile.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\DavidPrac\VSProjects\ReportEditor\Reporting.Green\Pics\source\arrow-red-up-24.png
        /// </remarks>
        public static System.Drawing.Image ArrowRedUp24_Cached
        {
            get
            {
                if (_ArrowRedUp24 == null) _ArrowRedUp24 = ArrowRedUp24;
                return _ArrowRedUp24;
            }
        }
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku arrow-red-up-24.png.
        /// Nelze používat jako Image pro Buttony, kde bude nastavováno Enabled = false (pak dojde k chybě .NET: Ot of memory).
        /// Pak je třeba použít Image ArrowRedUp24_FromFile.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití ArrowRedUp24_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property ArrowRedUp24_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\DavidPrac\VSProjects\ReportEditor\Reporting.Green\Pics\source\arrow-red-up-24.png
        /// </remarks>
        public static System.Drawing.Image ArrowRedUp24 { get { return _ImageCreateFrom(_ArrowRedUp24_string, null); } }
        /// <summary>
        /// Vrátí obrázek, načtený ze souboru arrow-red-up-24.png.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití ArrowRedUp24_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property ArrowRedUp24_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\DavidPrac\VSProjects\ReportEditor\Reporting.Green\Pics\source\arrow-red-up-24.png
        /// </remarks>
        public static System.Drawing.Image ArrowRedUp24_FromFile { get { return _ImageCreateFrom(_ArrowRedUp24_string, "arrow-red-up-24.png"); } }
        /// <summary>
        /// Vygeneruje a vrátí string, který definuje obsah souboru ArrowRedUp24
        /// </summary>
        /// <returns></returns>
        private static string _ArrowRedUp24_string()
        {
            System.Text.StringBuilder sb = new System.Text.StringBuilder(1340);
            sb.Append("iVBORw0KGgoAAAANSUhEUgAAABgAAAAMCAYAAAB4MH11AAAABGdBTUEAAK/INwWK6QAAAAlwSFlzAAAOwgAADsIBFShKgAAAAA10RVh0U291cmNlAE51dm9sYaxPNfEA");
            sb.Append("AAAadEVYdFNvZnR3YXJlAFBhaW50Lk5FVCB2My41LjExR/NCNwAAA09JREFUOE91U3tIU1EYP2sVFEUvKljunnubWkZpu7vn3j3y+sipiwor6o+CCCHoAUEFPaAQosCg");
            sb.Append("9x9hVGRl5aOpa3OytLLN2sycmVYUREWRaWY5egnF19dIe7j++PGdc/jO73fO7/s+otPpoihS9NG43zFNe8ARpz1kn6Y9bI/TnGUcKY+Cjq6QaaqTcZmVjI51S5RgJE4T");
            sb.Append("1VQwTuuUqbZK4bTns/TkKuMHeQcXp+ZwpEjSkxNMT07KHDmN8azpF7nMjXOaDRuuL8964F86/4lHMWxzMTrJJ/GkRqTEa0Jg9GGsN/HkhhhD4F9cxgulNo5csnATKq3x");
            sb.Append("Oxvzl716fbAQOtflQ5Oa3F3Lpu+tYXSqX6HkJubG4viJmIfl+JsSlSNlZi6uSk3aH9y4urf7+DH4tGk9RNJleJNlgbA6N1LPDMfrJBrvQ6tu4ctjcQ05KJcpOWNEcplL");
            sb.Append("dOeKRS07Nvb1Fp+Gz9u3QK/dAj0sCSK2FOjJskFHmulTo5JQ0iDxyQ0S1QT/sGYAf21KzRwpztBr0JZkd45Udn/fzs+RslL4sqcAulcsgjY1ub/VOutrV7YFIvMV6M1R");
            sb.Append("4XGm3B80J9Y0Ml72G+mw5n9+8hf5+Xl6Lb481ZuXevXR0cJvH69cgf4jR6Br7Rq4m6P0+JhwuN6SWNi6PPtN14oFUZH3OWnwLNv2PWyeGQiJfHZI4ke0xioyCmgrZMFe");
            sb.Append("t8oReFpc9O1LQwD6z12Aru1boclh6/Qpht1Y1Ml1Mp1wMzVp873F6vPORRnQl86gz5EBL3PV7x3W2c1hUVgSFvkRQwQuWrlJbrtY+eDQXvhQ44HIuRJ4WbALgnlpz71M");
            sb.Append("2ITk473Y+3VY0BtmfkzAHJ9/L0N8/MI2B97OS4F3uWnwwm6FdvMMX1jipwwRwF4f67LNLKjPS7/lX2oP+ReqoWuZohfJV3pkOsqDxAO513Dtl/mRQSYsDkvTXe2SIfSQ");
            sb.Append("JYYeKkm3202GwjaRHzeQO3jJNTs6meOdCmeoUmiCC+FmNK7WREd6kdA397dAAD32M4Gg58PvSILujpFPaDHxCei9oU0UJnYYBc1A7uCl6hQUwMmtwjatxulFcuJBS2qN");
            sb.Append("/x+iJiNPkJw0I1pQtBUjChAU+JWjIz8AUfFqijdEuMEAAAAASUVORK5CYII=");
            return sb.ToString();
        }
        /// <summary>
        /// Resetuje obrázek v paměti.
        /// Následující použití property ArrowRedUp24_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
        /// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
        /// </summary>
        public static void ArrowRedUp24_Reset()
        {
            _ArrowRedUp24 = null;
        }
        /// <summary>
        /// Úložiště objektu v paměti, při prvním použití ArrowRedUp24_Direct je objekt naplněn a následně využíván.
        /// </summary>
        private static System.Drawing.Image _ArrowRedUp24 = null;
        #endregion
        #region Image ArrowRedUp32
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku arrow-red-up-32.png.
        /// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
        /// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
        /// Případně je možno vyvolat metodu ArrowRedUp32_Reset(), která zajistí regenerování obrázku z jeho definice.
        /// Bezpečnější je používání property ArrowRedUp32, která vrací vždy nový objekt.
        /// Pro používání pro Button.Image, kde bude nastavováno Button.Enabled = false; je třeba použít property ArrowRedUp32_FromFile.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\DavidPrac\VSProjects\ReportEditor\Reporting.Green\Pics\source\arrow-red-up-32.png
        /// </remarks>
        public static System.Drawing.Image ArrowRedUp32_Cached
        {
            get
            {
                if (_ArrowRedUp32 == null) _ArrowRedUp32 = ArrowRedUp32;
                return _ArrowRedUp32;
            }
        }
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku arrow-red-up-32.png.
        /// Nelze používat jako Image pro Buttony, kde bude nastavováno Enabled = false (pak dojde k chybě .NET: Ot of memory).
        /// Pak je třeba použít Image ArrowRedUp32_FromFile.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití ArrowRedUp32_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property ArrowRedUp32_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\DavidPrac\VSProjects\ReportEditor\Reporting.Green\Pics\source\arrow-red-up-32.png
        /// </remarks>
        public static System.Drawing.Image ArrowRedUp32 { get { return _ImageCreateFrom(_ArrowRedUp32_string, null); } }
        /// <summary>
        /// Vrátí obrázek, načtený ze souboru arrow-red-up-32.png.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití ArrowRedUp32_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property ArrowRedUp32_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\DavidPrac\VSProjects\ReportEditor\Reporting.Green\Pics\source\arrow-red-up-32.png
        /// </remarks>
        public static System.Drawing.Image ArrowRedUp32_FromFile { get { return _ImageCreateFrom(_ArrowRedUp32_string, "arrow-red-up-32.png"); } }
        /// <summary>
        /// Vygeneruje a vrátí string, který definuje obsah souboru ArrowRedUp32
        /// </summary>
        /// <returns></returns>
        private static string _ArrowRedUp32_string()
        {
            System.Text.StringBuilder sb = new System.Text.StringBuilder(1728);
            sb.Append("iVBORw0KGgoAAAANSUhEUgAAACAAAAAQCAYAAAB3AH1ZAAAABGdBTUEAAK/INwWK6QAAAAlwSFlzAAAOwgAADsIBFShKgAAAAA10RVh0U291cmNlAE51dm9sYaxPNfEA");
            sb.Append("AAAadEVYdFNvZnR3YXJlAFBhaW50Lk5FVCB2My41LjExR/NCNwAABHNJREFUSEu9lW1MW1UYx89EDI7El5jsA0rPLR1lYyv0vpVSoAZWKB2iYIhMYzTDRZcZfMMtuvhJ");
            sb.Append("TFzUxJhtHyAwt/hB7QsUCuWtHWzAkHcRNmQkDDTRbchG7zomMH18bidLK5ftmx9+uec89+X/f55zznNJXFxcBFW8ilQJ8aQaqRHjyQlBRU5i7BRPyTesKvSMk6OknqVR");
            sb.Append("Tl6lrhNpopun0R68L9/73qAiTXi/GedevLawlLThuAPHPp6J0JJZF5CpZuNJLaciJ5CTyKmQgTBxHX3QIar21KdpzjUYNcNuge5vYmmMLCg/40HR5rviDGnnGOLDcbjG");
            sb.Append("GopBJep0lLgwE6detRnF33Cbt/82evAATFYcgFZT0nWPQD9EA4+0orCfXZ/pRigGlZDFXXoaaxfpB43ZO+cnP/kIluwOuFnxLkxZTNBu2Co1C/QIZvyEUqk3QjEYjgMz");
            sb.Append("wozl0m9B8c+8VjE4/eURWHa6ILi/DKSMVJDysmAmLwO60rR/tvK0Bsut7kQTZ7H0St8MRzG4hjOFEjtuKodAn0Tx2pairFtzX1fBirsBbr65DySzHgK8FqT0nWjCDL9a");
            sb.Append("zdBr2r6KFXCjAW2vkSE/3MeEYlBG3mz2dBWxC3SHXVQ5/K8W3r7sssOquxGW3iuHG4UWuJItwu/GHbDIJUJANoEGLhfkwFCW7u8ujvrP8oxxOfmre5pQDNZh5h1qHUFh");
            sb.Append("0S4y/q59JX8ttHthpdEDS4cPwY1XXoTZgmzoNibdPiNqVi/tzgIpPxMCJl3IxB/P5sFoVip0c8xwL8fs6ktRPzC0gYl1ATnzBi3dhOJWh0kz2nfwdQj0dsOKpxluVX4M");
            sb.Append("wXfegpnSQvCna4MtPD2Ka/5pt82wOPs2LklxLpq4U4mFony4kC1An5gw3ccxLwyx6qgRTr1OL2KCR4w4scFgMyl2mbdNjVQeguDwMKy2dsDy0WOwhAYuvlwCPlOS5BVo");
            sb.Append("JZ7vx/wsjfWJtKLHwl2dKSsFqTAHAhkpIROLRbth2mKEQVHzywDH7B3RMzFj/zERMUEDUbjmLzVYUufOH/8cln+egtWuHlj5Fo/bseMwWbYH2tO2zqP4++16ujnUYHC3");
            sb.Append("n+GYhzoFWtaTmTx3scQG1624JP+akIqfgVm8jhoSr47w6nI0EB2uGWHAwaseRfwDh8tBGuqHoLcVpO9csFhdC2N7S6HNlDiH4q+16enDcsNZe++0QEkPy0R3C8zz54za");
            sb.Append("85NPs3BFTIKFDB1cy82Ea0U2uISV+JFT94/x6sfDNe8OZLDZxCBfeC38vK8gQ/Jb06TTeQbJv4sPtIgJgyj+nE9Ho+T2Gv6eDG44MrEtYRNuOjPu+k7MdnGMT5DGeY00");
            sb.Append("YdBKE6J24Sc9UzPOq2PD34v4CJ53Us/TLfiDyak3UFuDSG2eO+Rjm03GkiuKr9GLLXgc6WcZzQDLWAdZxjbMMbYRBLPPRQNPTQr32AMyaCAEihPs7wTFSRPO5R9LeNk3");
            sb.Append("Qj7zaICgASIfPRQnoziWNx8aIBfuZ+D/JY78AwKzTycNXIlJAAAAAElFTkSuQmCC");
            return sb.ToString();
        }
        /// <summary>
        /// Resetuje obrázek v paměti.
        /// Následující použití property ArrowRedUp32_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
        /// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
        /// </summary>
        public static void ArrowRedUp32_Reset()
        {
            _ArrowRedUp32 = null;
        }
        /// <summary>
        /// Úložiště objektu v paměti, při prvním použití ArrowRedUp32_Direct je objekt naplněn a následně využíván.
        /// </summary>
        private static System.Drawing.Image _ArrowRedUp32 = null;
        #endregion
        #region Image ArrowSilverDown16
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku arrow-silver-down-16.png.
        /// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
        /// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
        /// Případně je možno vyvolat metodu ArrowSilverDown16_Reset(), která zajistí regenerování obrázku z jeho definice.
        /// Bezpečnější je používání property ArrowSilverDown16, která vrací vždy nový objekt.
        /// Pro používání pro Button.Image, kde bude nastavováno Button.Enabled = false; je třeba použít property ArrowSilverDown16_FromFile.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\DavidPrac\VSProjects\ReportEditor\Reporting.Green\Pics\source\arrow-silver-down-16.png
        /// </remarks>
        public static System.Drawing.Image ArrowSilverDown16_Cached
        {
            get
            {
                if (_ArrowSilverDown16 == null) _ArrowSilverDown16 = ArrowSilverDown16;
                return _ArrowSilverDown16;
            }
        }
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku arrow-silver-down-16.png.
        /// Nelze používat jako Image pro Buttony, kde bude nastavováno Enabled = false (pak dojde k chybě .NET: Ot of memory).
        /// Pak je třeba použít Image ArrowSilverDown16_FromFile.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití ArrowSilverDown16_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property ArrowSilverDown16_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\DavidPrac\VSProjects\ReportEditor\Reporting.Green\Pics\source\arrow-silver-down-16.png
        /// </remarks>
        public static System.Drawing.Image ArrowSilverDown16 { get { return _ImageCreateFrom(_ArrowSilverDown16_string, null); } }
        /// <summary>
        /// Vrátí obrázek, načtený ze souboru arrow-silver-down-16.png.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití ArrowSilverDown16_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property ArrowSilverDown16_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\DavidPrac\VSProjects\ReportEditor\Reporting.Green\Pics\source\arrow-silver-down-16.png
        /// </remarks>
        public static System.Drawing.Image ArrowSilverDown16_FromFile { get { return _ImageCreateFrom(_ArrowSilverDown16_string, "arrow-silver-down-16.png"); } }
        /// <summary>
        /// Vygeneruje a vrátí string, který definuje obsah souboru ArrowSilverDown16
        /// </summary>
        /// <returns></returns>
        private static string _ArrowSilverDown16_string()
        {
            System.Text.StringBuilder sb = new System.Text.StringBuilder(756);
            sb.Append("iVBORw0KGgoAAAANSUhEUgAAABAAAAAICAYAAADwdn+XAAAABGdBTUEAAK/INwWK6QAAAAlwSFlzAAAOwgAADsIBFShKgAAAAA10RVh0U291cmNlAE51dm9sYaxPNfEA");
            sb.Append("AAAadEVYdFNvZnR3YXJlAFBhaW50Lk5FVCB2My41LjExR/NCNwAAAZhJREFUKFNVkTtIQmEUx89URBBNbQ3iXVyMQFzygQ/wcRXf1weKioEmvhARt+A6tLi6CNLgeKFF");
            sb.Append("EHIKx6Aho6WWOwrNtzCw0/k+Qmk497vc+/1//3P+BzRNA6/X+1Iul9eFQuEzFot9uN3uS5/PB+FwGOLxOESjUXZKqVRqlU6n18Vi8Tubzb4xLQcEg0F1Pp+jqqqoKArm");
            sb.Append("crmNx+PpMQABWV2RwVepVMJ6vY7dbpfdWW0BFovlPBKJPE+nU1wulzgajTCfz2MoFJITiUSv3W5vWq0WNhoN7HQ6TPyeTCYvtgCbzQZWq1UQRfFpMpngYrHAfr+PmUyG");
            sb.Append("gX6azSbWajUOoG+vkiSd0Thcyx8kBpfLxbI4pnEexuMxzmYz3i5dxGq1ygE0/yM5n9IJBNkBzGYzL5qbBXZEkLvhcMjzoPaxUqkw0D25nxCAh+v3+3cAk8kEOp0OjEYj");
            sb.Append("y4OFtk91OxgMUJZlpA0o5HoYCARYl+B0OoFt6R9AEATQ6/VgMBjA4XAACfbI7Zpcb+j9gPIBu93O/9Ga/wAa/AIB8eJjZ/yT4AAAAABJRU5ErkJggg==");
            return sb.ToString();
        }
        /// <summary>
        /// Resetuje obrázek v paměti.
        /// Následující použití property ArrowSilverDown16_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
        /// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
        /// </summary>
        public static void ArrowSilverDown16_Reset()
        {
            _ArrowSilverDown16 = null;
        }
        /// <summary>
        /// Úložiště objektu v paměti, při prvním použití ArrowSilverDown16_Direct je objekt naplněn a následně využíván.
        /// </summary>
        private static System.Drawing.Image _ArrowSilverDown16 = null;
        #endregion
        #region Image ArrowSilverDown24
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku arrow-silver-down-24.png.
        /// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
        /// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
        /// Případně je možno vyvolat metodu ArrowSilverDown24_Reset(), která zajistí regenerování obrázku z jeho definice.
        /// Bezpečnější je používání property ArrowSilverDown24, která vrací vždy nový objekt.
        /// Pro používání pro Button.Image, kde bude nastavováno Button.Enabled = false; je třeba použít property ArrowSilverDown24_FromFile.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\DavidPrac\VSProjects\ReportEditor\Reporting.Green\Pics\source\arrow-silver-down-24.png
        /// </remarks>
        public static System.Drawing.Image ArrowSilverDown24_Cached
        {
            get
            {
                if (_ArrowSilverDown24 == null) _ArrowSilverDown24 = ArrowSilverDown24;
                return _ArrowSilverDown24;
            }
        }
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku arrow-silver-down-24.png.
        /// Nelze používat jako Image pro Buttony, kde bude nastavováno Enabled = false (pak dojde k chybě .NET: Ot of memory).
        /// Pak je třeba použít Image ArrowSilverDown24_FromFile.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití ArrowSilverDown24_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property ArrowSilverDown24_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\DavidPrac\VSProjects\ReportEditor\Reporting.Green\Pics\source\arrow-silver-down-24.png
        /// </remarks>
        public static System.Drawing.Image ArrowSilverDown24 { get { return _ImageCreateFrom(_ArrowSilverDown24_string, null); } }
        /// <summary>
        /// Vrátí obrázek, načtený ze souboru arrow-silver-down-24.png.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití ArrowSilverDown24_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property ArrowSilverDown24_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\DavidPrac\VSProjects\ReportEditor\Reporting.Green\Pics\source\arrow-silver-down-24.png
        /// </remarks>
        public static System.Drawing.Image ArrowSilverDown24_FromFile { get { return _ImageCreateFrom(_ArrowSilverDown24_string, "arrow-silver-down-24.png"); } }
        /// <summary>
        /// Vygeneruje a vrátí string, který definuje obsah souboru ArrowSilverDown24
        /// </summary>
        /// <returns></returns>
        private static string _ArrowSilverDown24_string()
        {
            System.Text.StringBuilder sb = new System.Text.StringBuilder(1168);
            sb.Append("iVBORw0KGgoAAAANSUhEUgAAABgAAAAMCAYAAAB4MH11AAAABGdBTUEAAK/INwWK6QAAAAlwSFlzAAAOwgAADsIBFShKgAAAAA10RVh0U291cmNlAE51dm9sYaxPNfEA");
            sb.Append("AAAadEVYdFNvZnR3YXJlAFBhaW50Lk5FVCB2My41LjExR/NCNwAAAs9JREFUOE+VlF1Ik2EUx8/asKA5ioJ1NcrwxtyFQ5bfTaebOjc3dZvOKerY8GN+EQOvZNDMXU02");
            sb.Append("yCthEA1CiWwQU4gy66bcVXRTF0F1EwldRCgRevo/L+8wkqgOHJ6X5z38/uec5zwPFayxsZHq6uokb2hoIJPJRE1NTdTS0iJHHDe3200ej4d6e3upr69PWgvfx8xisQi4");
            sb.Append("ura29iLWEoiUQPSC2WxWWq1WstvtciSRzWajnp4e4UoIaL1ebynApVgvYdX4fD458herqak5jWwjyOoJgp7Bn3d1dd2DsB0iRR0dHXIkSfDOzk4VYs2A3kXGL/1+/4vB");
            sb.Append("wcGn/f3989grlkOPzGg0nnc4HA+SySRvbGzw+vo6p1Kpw6Ghobft7e0BZK12Op0EUXK5XKeQuWdkZOTV8PDwIVaempriyclJHhgYeAQBrYw9MlSgQqaOsbGxnbW1tYN8");
            sb.Append("Ps+5XI6XlpYYgPeAX4efgYAaGYcmJibeTE9P8+joKM/MzPDs7OxhIBB4jfb4IFAkY48MAoT+q9B3C7LeTqfTB1tbW7y6usqxWEyIfOru7r6J1s0D/CESiTCSYSGC7EWl");
            sb.Append("O/jnQmEnISBTf7P6+npqbm5WoJKr6OnD5eXl75ubm7yyssJzc3MMyD76vBcOhyW4aAkq+YG9x4Begyv/CC8Y4GI8FW1tbXqI3EkkEt+y2SyLsxkfH2fAGK1gWWQfPb8P");
            sb.Append("qBF+AhXIlL+YGEudTkeYnMto6a2FhYWvOBdeXFzkUCgkwbHuYWJuA3ylcAf+y8Tci2owjlqI3IhGo58zmQzH43EOBoNfsJcAXCdG9p/gaAVVVlaSXq+nsrIyKi8vp6qq");
            sb.Append("KhKjCcg5ZItzjbyDf0TrooBrBVhcOpGIuPGi8tbWVmnvmBkMBumZ0Gg0CrVaLfnu7i5VVFRIFwvTUQy3AeyEn8W39JyI5wITqKiurlYgQYXYx72RqUQ/ATdtNkucfaxb");
            sb.Append("AAAAAElFTkSuQmCC");
            return sb.ToString();
        }
        /// <summary>
        /// Resetuje obrázek v paměti.
        /// Následující použití property ArrowSilverDown24_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
        /// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
        /// </summary>
        public static void ArrowSilverDown24_Reset()
        {
            _ArrowSilverDown24 = null;
        }
        /// <summary>
        /// Úložiště objektu v paměti, při prvním použití ArrowSilverDown24_Direct je objekt naplněn a následně využíván.
        /// </summary>
        private static System.Drawing.Image _ArrowSilverDown24 = null;
        #endregion
        #region Image ArrowSilverDown32
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku arrow-silver-down-32.png.
        /// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
        /// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
        /// Případně je možno vyvolat metodu ArrowSilverDown32_Reset(), která zajistí regenerování obrázku z jeho definice.
        /// Bezpečnější je používání property ArrowSilverDown32, která vrací vždy nový objekt.
        /// Pro používání pro Button.Image, kde bude nastavováno Button.Enabled = false; je třeba použít property ArrowSilverDown32_FromFile.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\DavidPrac\VSProjects\ReportEditor\Reporting.Green\Pics\source\arrow-silver-down-32.png
        /// </remarks>
        public static System.Drawing.Image ArrowSilverDown32_Cached
        {
            get
            {
                if (_ArrowSilverDown32 == null) _ArrowSilverDown32 = ArrowSilverDown32;
                return _ArrowSilverDown32;
            }
        }
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku arrow-silver-down-32.png.
        /// Nelze používat jako Image pro Buttony, kde bude nastavováno Enabled = false (pak dojde k chybě .NET: Ot of memory).
        /// Pak je třeba použít Image ArrowSilverDown32_FromFile.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití ArrowSilverDown32_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property ArrowSilverDown32_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\DavidPrac\VSProjects\ReportEditor\Reporting.Green\Pics\source\arrow-silver-down-32.png
        /// </remarks>
        public static System.Drawing.Image ArrowSilverDown32 { get { return _ImageCreateFrom(_ArrowSilverDown32_string, null); } }
        /// <summary>
        /// Vrátí obrázek, načtený ze souboru arrow-silver-down-32.png.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití ArrowSilverDown32_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property ArrowSilverDown32_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\DavidPrac\VSProjects\ReportEditor\Reporting.Green\Pics\source\arrow-silver-down-32.png
        /// </remarks>
        public static System.Drawing.Image ArrowSilverDown32_FromFile { get { return _ImageCreateFrom(_ArrowSilverDown32_string, "arrow-silver-down-32.png"); } }
        /// <summary>
        /// Vygeneruje a vrátí string, který definuje obsah souboru ArrowSilverDown32
        /// </summary>
        /// <returns></returns>
        private static string _ArrowSilverDown32_string()
        {
            System.Text.StringBuilder sb = new System.Text.StringBuilder(1396);
            sb.Append("iVBORw0KGgoAAAANSUhEUgAAACAAAAAQCAYAAAB3AH1ZAAAABGdBTUEAAK/INwWK6QAAAAlwSFlzAAAOwgAADsIBFShKgAAAAA10RVh0U291cmNlAE51dm9sYaxPNfEA");
            sb.Append("AAAadEVYdFNvZnR3YXJlAFBhaW50Lk5FVCB2My41LjExR/NCNwAAA3lJREFUSEvNlUtIVGEUx79BGbOiIAMhRNoFoQwjURqOj2bG14xvx/drfKTg20nFiQEFTQgGQcTZ");
            sb.Append("tNCFC8V0oSA6o7YQN067BMNFhRBCWhIWvfD0Px9XEwbNyKADh3OZuff+/uf/ne9+4r8LnU4nMyYmRsTFxYn4+Hih1+uF0WgUSUlJyl0nh8ViEbm5uSI/P18UFBTIPLg+");
            sb.Append("MaKjoxl+GfUu0ggRBogw3EMYDIbrwcHBIiUlRbnbNxis5DUI0ANqBtSEmojU4foqCzk2AA2AAEdycvJmenr6DmdmZibXdwkJCW6kLi0tTZWamqo88SsYzI7l5ORocD2V");
            sb.Append("l5e3DdinwsLCveLi4l3kWwhw4rdA5RHf4O6Rz7q6umh5eZlmZ2dpenqaxsbGqKWlhdD9OsRZIMAfopSnBEPZchUqd71aUVFBAJLVaqW6ujpqb2+XFQK8+P+K8phvxMbG");
            sb.Append("+sP22uzs7K3R0VHa2Nggr9dLS0tLNDExQTabjeDAa7PZXJWRkRGQlZUl4ejWDzUL3b5obW2lxsZGYhENDQ1kt9uJfystLd2FgIdItYLzDQgQWG41RJQDsjk4OEhra2vS");
            sb.Append("jcnJSRoZGaG2tjYCeAcCHqCeB1gNwdaSkpJNh8MhRXLnDO/s7JRiioqKtiHSBvhFpEI7JngdYbM/Jj8HItb7+voOXWABAwMDsiOs8weAH0GAvbKycqu3t1fCy8vLJbyj");
            sb.Append("o0PaDlfewPZqgM8x/LcCODBsApapUI1Y9+fobH9lZYU8Hg8NDQ1RT0+PhODF39HZt6amJmpubj6Es0s1NTW85uu4Jxsi/E4FPhqJiYkCL+VtdxtOePDS/cXFRVpYWCCn");
            sb.Append("0yldYAhDeeAO4OxCdXU1w1cBNwCu+mP4QZhMJjkXmPobGL6nAHydmZkht9tNbHlVVRVh7Q/XnF3A8P0AeAF5KyQk5HSWnxS85+GAwMCF4pvwpLa29sv4+DjNz89Td3e3");
            sb.Append("7Ly+vp54GcrKyhg+BehNLM3fw48G4Lzlgnjw0PnH4eFhmpubo/7+ftk9nPgMuAvQUNSzhXPwngecv+mX8NGxw/b3LpdLDiVc2EPHjwEN+ifwo8HWYl8HoN7H8L3EbnkF");
            sb.Append("aAegF84EHBkZKSIiIkR4eLgICwuTVaPRCK1WK6KiouQ9DEKqIUKLvIPrQO78IPgExQdN4ACTpyjvKD5JfQ8yIX4C2Erdrcp3pIoAAAAASUVORK5CYII=");
            return sb.ToString();
        }
        /// <summary>
        /// Resetuje obrázek v paměti.
        /// Následující použití property ArrowSilverDown32_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
        /// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
        /// </summary>
        public static void ArrowSilverDown32_Reset()
        {
            _ArrowSilverDown32 = null;
        }
        /// <summary>
        /// Úložiště objektu v paměti, při prvním použití ArrowSilverDown32_Direct je objekt naplněn a následně využíván.
        /// </summary>
        private static System.Drawing.Image _ArrowSilverDown32 = null;
        #endregion
        #region Image ArrowSilverLeft16
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku arrow-silver-left-16.png.
        /// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
        /// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
        /// Případně je možno vyvolat metodu ArrowSilverLeft16_Reset(), která zajistí regenerování obrázku z jeho definice.
        /// Bezpečnější je používání property ArrowSilverLeft16, která vrací vždy nový objekt.
        /// Pro používání pro Button.Image, kde bude nastavováno Button.Enabled = false; je třeba použít property ArrowSilverLeft16_FromFile.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\DavidPrac\VSProjects\ReportEditor\Reporting.Green\Pics\source\arrow-silver-left-16.png
        /// </remarks>
        public static System.Drawing.Image ArrowSilverLeft16_Cached
        {
            get
            {
                if (_ArrowSilverLeft16 == null) _ArrowSilverLeft16 = ArrowSilverLeft16;
                return _ArrowSilverLeft16;
            }
        }
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku arrow-silver-left-16.png.
        /// Nelze používat jako Image pro Buttony, kde bude nastavováno Enabled = false (pak dojde k chybě .NET: Ot of memory).
        /// Pak je třeba použít Image ArrowSilverLeft16_FromFile.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití ArrowSilverLeft16_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property ArrowSilverLeft16_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\DavidPrac\VSProjects\ReportEditor\Reporting.Green\Pics\source\arrow-silver-left-16.png
        /// </remarks>
        public static System.Drawing.Image ArrowSilverLeft16 { get { return _ImageCreateFrom(_ArrowSilverLeft16_string, null); } }
        /// <summary>
        /// Vrátí obrázek, načtený ze souboru arrow-silver-left-16.png.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití ArrowSilverLeft16_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property ArrowSilverLeft16_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\DavidPrac\VSProjects\ReportEditor\Reporting.Green\Pics\source\arrow-silver-left-16.png
        /// </remarks>
        public static System.Drawing.Image ArrowSilverLeft16_FromFile { get { return _ImageCreateFrom(_ArrowSilverLeft16_string, "arrow-silver-left-16.png"); } }
        /// <summary>
        /// Vygeneruje a vrátí string, který definuje obsah souboru ArrowSilverLeft16
        /// </summary>
        /// <returns></returns>
        private static string _ArrowSilverLeft16_string()
        {
            System.Text.StringBuilder sb = new System.Text.StringBuilder(720);
            sb.Append("iVBORw0KGgoAAAANSUhEUgAAAAgAAAAQCAYAAAArij59AAAABGdBTUEAAK/INwWK6QAAAAlwSFlzAAAOwgAADsIBFShKgAAAAA10RVh0U291cmNlAE51dm9sYaxPNfEA");
            sb.Append("AAAadEVYdFNvZnR3YXJlAFBhaW50Lk5FVCB2My41LjExR/NCNwAAAX9JREFUKFN9kTtPAlEQhedvWNksSxbkvUAgvBIgQCQhBCgM29AsJjyksSAaaOQ/WBEbKmigpNhQ");
            sb.Append("YkNsTNQKGjoLi42FxXHuLbQxbnIy9+58M3N2lmzb/lfk9/ulAoGAlDjrun6VyWTA5xvyer1SHo9HSlXVy16vh/l8DgY38qXL5SJN08jhcBj1ev1rv99juVwiGAxaPwAn");
            sb.Append("z/n52G632O12GI/H4JEPElAUJcIzj5ZlYb1eYzQaIRKJPDNwSk6nU4tGo6+r1QqLxQL9fh+xWOzg8/nOOBJx8mk2m2E6ncIwDPD9yJWBUChEiUSCKJVKvUwmE5imCTaI");
            sb.Append("dDp9YEjlKHJEbrdbZ/rQbrfR6XQwGAxQKpXeuFrJZrMkTfIeslzx3u12IXYgYqFQeMzlcicSENsLh8MXxWLxU3QQQKPRAAP3YgSxYwEQuzar1SqGwyFarZboYlE8Hpdu");
            sb.Append("k8kkCWOs62azKT+3XC5vKJ/PS3E7KWGMK29rtRoqlcrdn7/4VzZ9A/NjztCyvCJyAAAAAElFTkSuQmCC");
            return sb.ToString();
        }
        /// <summary>
        /// Resetuje obrázek v paměti.
        /// Následující použití property ArrowSilverLeft16_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
        /// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
        /// </summary>
        public static void ArrowSilverLeft16_Reset()
        {
            _ArrowSilverLeft16 = null;
        }
        /// <summary>
        /// Úložiště objektu v paměti, při prvním použití ArrowSilverLeft16_Direct je objekt naplněn a následně využíván.
        /// </summary>
        private static System.Drawing.Image _ArrowSilverLeft16 = null;
        #endregion
        #region Image ArrowSilverLeft24
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku arrow-silver-left-24.png.
        /// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
        /// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
        /// Případně je možno vyvolat metodu ArrowSilverLeft24_Reset(), která zajistí regenerování obrázku z jeho definice.
        /// Bezpečnější je používání property ArrowSilverLeft24, která vrací vždy nový objekt.
        /// Pro používání pro Button.Image, kde bude nastavováno Button.Enabled = false; je třeba použít property ArrowSilverLeft24_FromFile.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\DavidPrac\VSProjects\ReportEditor\Reporting.Green\Pics\source\arrow-silver-left-24.png
        /// </remarks>
        public static System.Drawing.Image ArrowSilverLeft24_Cached
        {
            get
            {
                if (_ArrowSilverLeft24 == null) _ArrowSilverLeft24 = ArrowSilverLeft24;
                return _ArrowSilverLeft24;
            }
        }
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku arrow-silver-left-24.png.
        /// Nelze používat jako Image pro Buttony, kde bude nastavováno Enabled = false (pak dojde k chybě .NET: Ot of memory).
        /// Pak je třeba použít Image ArrowSilverLeft24_FromFile.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití ArrowSilverLeft24_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property ArrowSilverLeft24_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\DavidPrac\VSProjects\ReportEditor\Reporting.Green\Pics\source\arrow-silver-left-24.png
        /// </remarks>
        public static System.Drawing.Image ArrowSilverLeft24 { get { return _ImageCreateFrom(_ArrowSilverLeft24_string, null); } }
        /// <summary>
        /// Vrátí obrázek, načtený ze souboru arrow-silver-left-24.png.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití ArrowSilverLeft24_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property ArrowSilverLeft24_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\DavidPrac\VSProjects\ReportEditor\Reporting.Green\Pics\source\arrow-silver-left-24.png
        /// </remarks>
        public static System.Drawing.Image ArrowSilverLeft24_FromFile { get { return _ImageCreateFrom(_ArrowSilverLeft24_string, "arrow-silver-left-24.png"); } }
        /// <summary>
        /// Vygeneruje a vrátí string, který definuje obsah souboru ArrowSilverLeft24
        /// </summary>
        /// <returns></returns>
        private static string _ArrowSilverLeft24_string()
        {
            System.Text.StringBuilder sb = new System.Text.StringBuilder(1092);
            sb.Append("iVBORw0KGgoAAAANSUhEUgAAAAwAAAAYCAYAAADOMhxqAAAABGdBTUEAAK/INwWK6QAAAAlwSFlzAAAOwgAADsIBFShKgAAAAA10RVh0U291cmNlAE51dm9sYaxPNfEA");
            sb.Append("AAAadEVYdFNvZnR3YXJlAFBhaW50Lk5FVCB2My41LjExR/NCNwAAApZJREFUOE+tU09okmEcfl1FEaNwxaC67DDwz9gf/07dpiiKm9MNcUKhzukmc2oK8yAxTxsRBAMP");
            sb.Append("EQRCdtqaXcTTKHaxPISMrkHHEUG7FEizbf16Xv3YGjno0AMfH9/7Ps/v9/ye9/3Yf8fw8DBTKBRsYGCA9ff3C6vnwGAwsN7eXtbX19cpk8lu4H1B2GoPXnFoaOjW6Ojo");
            sb.Append("47GxsZfoohO2zkKj0fCq3MZNkB9ls9nvyWTyB8T3BcpZSCQSJpfLr2m12gfpdHq/Wq3S2tpaQ6lUpgXKKfhw8HsFg8aj0ejnnZ0dqtVqtLKy0lCpVGcFvDJ8X4bo3uzs");
            sb.Append("7KdSqUSVSoW2trZoYWFhHx38ApXxqpzcAe8Oj8fzYXNzk7a3t6lQKFAikTjA0HkI7jTJg4ODXCDCY5ycnHyXz+d/lctlyuVytLS0dATyK1iUrq+vN/lcwMkKq9X6GqSj");
            sb.Append("YrFIq6urFA6HD00m0xtUVuIARWq1uiUAuUun0z1DEocbGxuUyWTI7/cTyLvgmkAUIbEWmUMqlfK8XyDvY6RBwWCQvF4vmc3m96isE4vFzGg0CmwAmXfAlh4V3/p8vmPE");
            sb.Append("ye1QJBL56XQ6S3q9Xlav15nFYjkR8JPtwEnasbgbCoUoFovxdAjixsTExHMM3nMi4OD3Bl4vwqt3fHz84+Li4okIFut2uz0HQbdAb4FfYwx/FfNEpqen9+LxeFMwPz9P");
            sb.Append("+P5is9nuCtRTwC8bGRnpxDwZDP41lUo1O83MzDTQ5e+7xMH/A6TShXN5iBC+LS8vUyAQ4LO0F8ASw5A8ldsOh+PJ3NxcHXfrAIklBUp7wBaDjZ6pqamnbre7jPcfh9EG");
            sb.Append("GJL/cQxWrqNTt8vluiRsnQ+QGS4kgx2GDsLqP4Ox3wij9/7BOiP9AAAAAElFTkSuQmCC");
            return sb.ToString();
        }
        /// <summary>
        /// Resetuje obrázek v paměti.
        /// Následující použití property ArrowSilverLeft24_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
        /// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
        /// </summary>
        public static void ArrowSilverLeft24_Reset()
        {
            _ArrowSilverLeft24 = null;
        }
        /// <summary>
        /// Úložiště objektu v paměti, při prvním použití ArrowSilverLeft24_Direct je objekt naplněn a následně využíván.
        /// </summary>
        private static System.Drawing.Image _ArrowSilverLeft24 = null;
        #endregion
        #region Image ArrowSilverLeft32
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku arrow-silver-left-32.png.
        /// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
        /// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
        /// Případně je možno vyvolat metodu ArrowSilverLeft32_Reset(), která zajistí regenerování obrázku z jeho definice.
        /// Bezpečnější je používání property ArrowSilverLeft32, která vrací vždy nový objekt.
        /// Pro používání pro Button.Image, kde bude nastavováno Button.Enabled = false; je třeba použít property ArrowSilverLeft32_FromFile.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\DavidPrac\VSProjects\ReportEditor\Reporting.Green\Pics\source\arrow-silver-left-32.png
        /// </remarks>
        public static System.Drawing.Image ArrowSilverLeft32_Cached
        {
            get
            {
                if (_ArrowSilverLeft32 == null) _ArrowSilverLeft32 = ArrowSilverLeft32;
                return _ArrowSilverLeft32;
            }
        }
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku arrow-silver-left-32.png.
        /// Nelze používat jako Image pro Buttony, kde bude nastavováno Enabled = false (pak dojde k chybě .NET: Ot of memory).
        /// Pak je třeba použít Image ArrowSilverLeft32_FromFile.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití ArrowSilverLeft32_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property ArrowSilverLeft32_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\DavidPrac\VSProjects\ReportEditor\Reporting.Green\Pics\source\arrow-silver-left-32.png
        /// </remarks>
        public static System.Drawing.Image ArrowSilverLeft32 { get { return _ImageCreateFrom(_ArrowSilverLeft32_string, null); } }
        /// <summary>
        /// Vrátí obrázek, načtený ze souboru arrow-silver-left-32.png.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití ArrowSilverLeft32_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property ArrowSilverLeft32_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\DavidPrac\VSProjects\ReportEditor\Reporting.Green\Pics\source\arrow-silver-left-32.png
        /// </remarks>
        public static System.Drawing.Image ArrowSilverLeft32_FromFile { get { return _ImageCreateFrom(_ArrowSilverLeft32_string, "arrow-silver-left-32.png"); } }
        /// <summary>
        /// Vygeneruje a vrátí string, který definuje obsah souboru ArrowSilverLeft32
        /// </summary>
        /// <returns></returns>
        private static string _ArrowSilverLeft32_string()
        {
            System.Text.StringBuilder sb = new System.Text.StringBuilder(1392);
            sb.Append("iVBORw0KGgoAAAANSUhEUgAAABAAAAAgCAYAAAAbifjMAAAABGdBTUEAAK/INwWK6QAAAAlwSFlzAAAOwgAADsIBFShKgAAAAA10RVh0U291cmNlAE51dm9sYaxPNfEA");
            sb.Append("AAAadEVYdFNvZnR3YXJlAFBhaW50Lk5FVCB2My41LjExR/NCNwAAA3VJREFUSEvVVF1Ik2EU/qapmUTYRUjUVSHhz3Sb/7/b1Dn/ExwoTNHpSPybmKz0oi4GjuGFid3M");
            sb.Append("K9ELwW4Eb4K03elM7ELIXcSguqgwQltE/56e8/Vm5jbbXfTAy2Df+zznnOec80r/H3JyciS1Wi0plUopLS1N/Bsh8vLypMLCwmiNRnMmIyMjlkUiRnZ2tlRUVBQDsjUz");
            sb.Append("M/Nhenr6bZxE8fl4gCiVlJREgWguKyt7NTw8TAUFBa9TU1O14kp4cOSamhoFyFfz8/Ofu91uWl1dJb1eH4AH9eJaaFRVVUn19fUSyHoIbTudTvL7/bS8vEw6nS4AD+rE");
            sb.Append("1WBkZWVJSUlJTNbgbNjtdvL5fLS1tUVLS0tyBjAyvAC3CMTLiHK/u7v7++bmJm1sbJDH46H5+XnSarV7KpWqWlz/E3CXyRcgstDa2rrv9XqJz+LiIi0sLJDVaiWU5EGW");
            sb.Append("lwTlN0DkQUmEw+7GxsZPKysrtLa2RnNzczQzM0PIhjBMT0HWoRMKQfsJ1CQhrdMpKSmOioqKjxxxfX2dpqenaXJyknp7ewnD9ALkZpio4ME6AEdGWnGIbC8uLn43Ozsr");
            sb.Append("R2aiw+GQIyPiLsjXQIzJzc0VTAEIxIJsQa/fTk1NyTWPj4/T0NAQWSwWwgjvgXwD5JNBZAbIStT+ZGxsTB4Ul8slm8VkTOEXjLALtSfwMoUE6tagBP/ExIRcc0dHB6ED");
            sb.Append("1NLSQhjlzyDeQhZxPNYhgdbF41xH/e+Z3N/fL4uYzWbq6uqiysrKHaRvLS0tPYEjWIfAvUcJCeiEE1E+cPoDAwPU3t5Og4ODNDIyQuXl5S/xzYQORGGpBPMQuI0wKhH1");
            sb.Append("3sWofu3p6TkQYTNZCMRteGJITk4WrCOAAL8653HuYZm+2Ww2WYTLYRHODCKPEUCNWRGsI+AVRjuvoO8PGhoaZCKLcEf6+vqoqalpHyJLELgoKMFAGfyQqGCq12QyEW/j");
            sb.Append("L5Hm5mY2dddgMBjF9WAgulRXV8cvkQ6b5+NusJEs0tbWRtXV1QGIhF9nBrcLaSog0IjfZ52dnTQ6Okpsbm1tbQAeHS/AYBFEikbNFhB2eKH4TYQ3AWTxdwEG+s8isajZ");
            sb.Append("BuIuZ4JVf4MsQgxDGHDLkMEpRL0J4iP4cwfv5TnxOTIYjUY2NgYCZ3HiccSXCIEy+ImXmMgd4hf7X0OSfgA31pjzMF+QUAAAAABJRU5ErkJggg==");
            return sb.ToString();
        }
        /// <summary>
        /// Resetuje obrázek v paměti.
        /// Následující použití property ArrowSilverLeft32_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
        /// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
        /// </summary>
        public static void ArrowSilverLeft32_Reset()
        {
            _ArrowSilverLeft32 = null;
        }
        /// <summary>
        /// Úložiště objektu v paměti, při prvním použití ArrowSilverLeft32_Direct je objekt naplněn a následně využíván.
        /// </summary>
        private static System.Drawing.Image _ArrowSilverLeft32 = null;
        #endregion
        #region Image ArrowSilverRight16
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku arrow-silver-right-16.png.
        /// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
        /// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
        /// Případně je možno vyvolat metodu ArrowSilverRight16_Reset(), která zajistí regenerování obrázku z jeho definice.
        /// Bezpečnější je používání property ArrowSilverRight16, která vrací vždy nový objekt.
        /// Pro používání pro Button.Image, kde bude nastavováno Button.Enabled = false; je třeba použít property ArrowSilverRight16_FromFile.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\DavidPrac\VSProjects\ReportEditor\Reporting.Green\Pics\source\arrow-silver-right-16.png
        /// </remarks>
        public static System.Drawing.Image ArrowSilverRight16_Cached
        {
            get
            {
                if (_ArrowSilverRight16 == null) _ArrowSilverRight16 = ArrowSilverRight16;
                return _ArrowSilverRight16;
            }
        }
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku arrow-silver-right-16.png.
        /// Nelze používat jako Image pro Buttony, kde bude nastavováno Enabled = false (pak dojde k chybě .NET: Ot of memory).
        /// Pak je třeba použít Image ArrowSilverRight16_FromFile.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití ArrowSilverRight16_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property ArrowSilverRight16_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\DavidPrac\VSProjects\ReportEditor\Reporting.Green\Pics\source\arrow-silver-right-16.png
        /// </remarks>
        public static System.Drawing.Image ArrowSilverRight16 { get { return _ImageCreateFrom(_ArrowSilverRight16_string, null); } }
        /// <summary>
        /// Vrátí obrázek, načtený ze souboru arrow-silver-right-16.png.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití ArrowSilverRight16_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property ArrowSilverRight16_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\DavidPrac\VSProjects\ReportEditor\Reporting.Green\Pics\source\arrow-silver-right-16.png
        /// </remarks>
        public static System.Drawing.Image ArrowSilverRight16_FromFile { get { return _ImageCreateFrom(_ArrowSilverRight16_string, "arrow-silver-right-16.png"); } }
        /// <summary>
        /// Vygeneruje a vrátí string, který definuje obsah souboru ArrowSilverRight16
        /// </summary>
        /// <returns></returns>
        private static string _ArrowSilverRight16_string()
        {
            System.Text.StringBuilder sb = new System.Text.StringBuilder(748);
            sb.Append("iVBORw0KGgoAAAANSUhEUgAAAAgAAAAQCAYAAAArij59AAAABGdBTUEAAK/INwWK6QAAAAlwSFlzAAAOwgAADsIBFShKgAAAAA10RVh0U291cmNlAE51dm9sYaxPNfEA");
            sb.Append("AAAadEVYdFNvZnR3YXJlAFBhaW50Lk5FVCB2My41LjExR/NCNwAAAZNJREFUKFN9UbtLQnEUPlMRQTS1tWiDIBpX8HlVFPX6REElRRAdEgx8oYNuYXcI/wAHB2mWJDel");
            sb.Append("LXALGiKbXMKloPkaDnY65y4t0fDBD873ON/5gaIo/wI8Hs+L3+9/M5lMgt1uB5fLBTabDfR6PRiNRoBCobCZzWYYDAafzWbzCROcTifodDrQarUA2Wx2vVqtcDKZIA2f");
            sb.Append("RFE8JEcQBAE0Gg1AKBT6HI1GuFgscDgcIqkf3G73QSAQAIPBAGCxWM5TqdR2MBjgfD7Hfr+P5HJHLru8k7oQkTrpdBplWcbpdIq9Xo/jbiKRyI5KYJDqKpFIYK1Ww/F4");
            sb.Append("jN1uFynmErxeL1Am1+0kk8nvXC6HrVYL2+02hsPhax4w4aJUKm1ZXalUMJ/Po8/nu6WIPSacZTKZr3q9jtVqFYnIN7mndvvsDJIkvReLRWw0Glgul9n2kXBEUHcDslnz");
            sb.Append("kB3o/Urq42g0qp6c2gFQvU2z2cR4PL4kt1NW8pEcDgdYrVaAWCy2pOEHKUXKBSbQglxb/ZM/v/gXCvwAP9fV86S2locAAAAASUVORK5CYII=");
            return sb.ToString();
        }
        /// <summary>
        /// Resetuje obrázek v paměti.
        /// Následující použití property ArrowSilverRight16_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
        /// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
        /// </summary>
        public static void ArrowSilverRight16_Reset()
        {
            _ArrowSilverRight16 = null;
        }
        /// <summary>
        /// Úložiště objektu v paměti, při prvním použití ArrowSilverRight16_Direct je objekt naplněn a následně využíván.
        /// </summary>
        private static System.Drawing.Image _ArrowSilverRight16 = null;
        #endregion
        #region Image ArrowSilverRight24
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku arrow-silver-right-24.png.
        /// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
        /// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
        /// Případně je možno vyvolat metodu ArrowSilverRight24_Reset(), která zajistí regenerování obrázku z jeho definice.
        /// Bezpečnější je používání property ArrowSilverRight24, která vrací vždy nový objekt.
        /// Pro používání pro Button.Image, kde bude nastavováno Button.Enabled = false; je třeba použít property ArrowSilverRight24_FromFile.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\DavidPrac\VSProjects\ReportEditor\Reporting.Green\Pics\source\arrow-silver-right-24.png
        /// </remarks>
        public static System.Drawing.Image ArrowSilverRight24_Cached
        {
            get
            {
                if (_ArrowSilverRight24 == null) _ArrowSilverRight24 = ArrowSilverRight24;
                return _ArrowSilverRight24;
            }
        }
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku arrow-silver-right-24.png.
        /// Nelze používat jako Image pro Buttony, kde bude nastavováno Enabled = false (pak dojde k chybě .NET: Ot of memory).
        /// Pak je třeba použít Image ArrowSilverRight24_FromFile.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití ArrowSilverRight24_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property ArrowSilverRight24_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\DavidPrac\VSProjects\ReportEditor\Reporting.Green\Pics\source\arrow-silver-right-24.png
        /// </remarks>
        public static System.Drawing.Image ArrowSilverRight24 { get { return _ImageCreateFrom(_ArrowSilverRight24_string, null); } }
        /// <summary>
        /// Vrátí obrázek, načtený ze souboru arrow-silver-right-24.png.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití ArrowSilverRight24_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property ArrowSilverRight24_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\DavidPrac\VSProjects\ReportEditor\Reporting.Green\Pics\source\arrow-silver-right-24.png
        /// </remarks>
        public static System.Drawing.Image ArrowSilverRight24_FromFile { get { return _ImageCreateFrom(_ArrowSilverRight24_string, "arrow-silver-right-24.png"); } }
        /// <summary>
        /// Vygeneruje a vrátí string, který definuje obsah souboru ArrowSilverRight24
        /// </summary>
        /// <returns></returns>
        private static string _ArrowSilverRight24_string()
        {
            System.Text.StringBuilder sb = new System.Text.StringBuilder(1132);
            sb.Append("iVBORw0KGgoAAAANSUhEUgAAAAwAAAAYCAYAAADOMhxqAAAABGdBTUEAAK/INwWK6QAAAAlwSFlzAAAOwgAADsIBFShKgAAAAA10RVh0U291cmNlAE51dm9sYaxPNfEA");
            sb.Append("AAAadEVYdFNvZnR3YXJlAFBhaW50Lk5FVCB2My41LjExR/NCNwAAArNJREFUOE+tUkFI01EcfqultKYUNQwhkOVtzIGObc65qXOburlNxcnCiTpdOt3YiJ0ESZLwIAMZ");
            sb.Append("XYaCRGgMsnVoHjo40pu7CF3qEBQdokPQwZBAf33v/4ZpBEH0wYPfe+/7vve933vsn2AwGM6Nv8JqtbLGxsYrDQ0NN3Q6nRx1eec8FAqFKPR6vbK1tTXlcrlemM1mLxcZ");
            sb.Append("jUaxeQaVlZWiaGpqqvN6vTvLy8s0Nja2j1gOmFxoaWkRhDKUSqVMKiBQ9/f37xYKBdrY2DgeHBx8DZHRZDLJbDabxOE4FcBN7ff797a2tqhUKlE2mz3G/CXiaQOBgMTh");
            sb.Append("OBXA7SbyP0un0yfb29tULBYJ9ZHP53tisVhut7e3s46ODi6Q+Ky5uVmOvF64veP3yOVyxIWLi4uHPT09jyCqaWtr+yXgHcGowEZ4aGjow8LCAq2urlI+n6e5ublvXV1d");
            sb.Append("D3DK9c7OTiHIZDIMF2QQVMHpHk76nEqlaGVlhTY3NymZTH7p7u5OQVAtFGVAwPAeV+H2EJ36Pj09TUtLS7S+vk6o3zscDneZKsBfHEPpdDrnBwYGDkOhEEUiEX4Xikaj");
            sb.Append("n7DuL1MZ45eC+2Us3h0fH/84NTVF4XCYEykYDH7t7e29j05ek8i8ZeiSHBkDw8PDbxOJBI9As7OzhDnvVBpGNRBIfIbMFyGyI8bBzMyMRI7FYjQ6Onrk8Xgeg3wL+ZlG");
            sb.Append("oxECu91eg8WnOPqYR4nH4zQxMfED/+s5XDVra2sMrT0nUKNteyMjI8TjQHSCr7EDkgEnyPr6+iSeVqsVXwPZ1bjULo+D3CeItg9nGwQyGEkcDpwgBMhXh39TnJycJDza");
            sb.Append("GxD9GHIe4yzq6+uFAG7Vbrd7HqJX6MgdzCt+J3OoVCpRgMRFVeXWXfoTmaO2tlYUIEld4HnPZv4PYOwnKfkMgAn/6+MAAAAASUVORK5CYII=");
            return sb.ToString();
        }
        /// <summary>
        /// Resetuje obrázek v paměti.
        /// Následující použití property ArrowSilverRight24_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
        /// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
        /// </summary>
        public static void ArrowSilverRight24_Reset()
        {
            _ArrowSilverRight24 = null;
        }
        /// <summary>
        /// Úložiště objektu v paměti, při prvním použití ArrowSilverRight24_Direct je objekt naplněn a následně využíván.
        /// </summary>
        private static System.Drawing.Image _ArrowSilverRight24 = null;
        #endregion
        #region Image ArrowSilverRight32
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku arrow-silver-right-32.png.
        /// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
        /// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
        /// Případně je možno vyvolat metodu ArrowSilverRight32_Reset(), která zajistí regenerování obrázku z jeho definice.
        /// Bezpečnější je používání property ArrowSilverRight32, která vrací vždy nový objekt.
        /// Pro používání pro Button.Image, kde bude nastavováno Button.Enabled = false; je třeba použít property ArrowSilverRight32_FromFile.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\DavidPrac\VSProjects\ReportEditor\Reporting.Green\Pics\source\arrow-silver-right-32.png
        /// </remarks>
        public static System.Drawing.Image ArrowSilverRight32_Cached
        {
            get
            {
                if (_ArrowSilverRight32 == null) _ArrowSilverRight32 = ArrowSilverRight32;
                return _ArrowSilverRight32;
            }
        }
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku arrow-silver-right-32.png.
        /// Nelze používat jako Image pro Buttony, kde bude nastavováno Enabled = false (pak dojde k chybě .NET: Ot of memory).
        /// Pak je třeba použít Image ArrowSilverRight32_FromFile.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití ArrowSilverRight32_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property ArrowSilverRight32_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\DavidPrac\VSProjects\ReportEditor\Reporting.Green\Pics\source\arrow-silver-right-32.png
        /// </remarks>
        public static System.Drawing.Image ArrowSilverRight32 { get { return _ImageCreateFrom(_ArrowSilverRight32_string, null); } }
        /// <summary>
        /// Vrátí obrázek, načtený ze souboru arrow-silver-right-32.png.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití ArrowSilverRight32_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property ArrowSilverRight32_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\DavidPrac\VSProjects\ReportEditor\Reporting.Green\Pics\source\arrow-silver-right-32.png
        /// </remarks>
        public static System.Drawing.Image ArrowSilverRight32_FromFile { get { return _ImageCreateFrom(_ArrowSilverRight32_string, "arrow-silver-right-32.png"); } }
        /// <summary>
        /// Vygeneruje a vrátí string, který definuje obsah souboru ArrowSilverRight32
        /// </summary>
        /// <returns></returns>
        private static string _ArrowSilverRight32_string()
        {
            System.Text.StringBuilder sb = new System.Text.StringBuilder(1336);
            sb.Append("iVBORw0KGgoAAAANSUhEUgAAABAAAAAgCAYAAAAbifjMAAAABGdBTUEAAK/INwWK6QAAAAlwSFlzAAAOwgAADsIBFShKgAAAAA10RVh0U291cmNlAE51dm9sYaxPNfEA");
            sb.Append("AAAadEVYdFNvZnR3YXJlAFBhaW50Lk5FVCB2My41LjExR/NCNwAAA01JREFUSEvNk01I03EYx/9L08oosG5FdAvzEMGcOp26ufn+uoZ6UNhk0/mObgxdDBS0QzDFi3no");
            sb.Append("oCAIQi4PHsT5gnhq0mmH9GQhJNgqInrHp+/z7/cXzfl28wsPm/6ez/d5+f0mnR9pNJq9SE1NFf89gwQch7gOg9j09HRxckoxiPAhFhFOrVYbhxCnp5BardYaDIYtr9dL");
            sb.Append("xcXF2ykpKdbMzMyY7OxskXGCYGDKz8+PrKys0NjYGOn1+ndpaWkWo9F4QafTiaxjhIrGvLy8yOzsLG1sbNDg4CCh+huMYYSxCiEyjxDm5sTIzMwMra2tUTgcpt7eXkL1");
            sb.Append("1xhFk5SUJGFEkR1F2LzBZDJ9mJycpKWlJVpdXaVQKEQul2sXJsGsrKx7x+4Drd5FpWBTUxNNTU3R9PQ0LS8vy0bNzc1s8iInJ+cOdiOI/4RDVUZGBvJ0662trTQ+Pi5H");
            sb.Append("MBik+fl5slqtP9HF89zc3BtYrKD2CaBUVFSkQhcWmG22t7fT8PAwjYyM0MLCAgUCAaqqqvqOsycwuIaFC3KfAEuY8yI+7agU4U76+/vJ7/fLXUxMTJDZbP6CZXoLCgou");
            sb.Append("Rb0ZtClhznh8ulHlU2NjI3V1ddHAwIBsMjo6SuXl5R/RhQMm8QI7KDZBqwncbmFh4S+73U4Oh4P6+vpobm5O7givdR0dPBTIQfF9Y4Q4dOJF0o/a2lqqq6vjRdLQ0JAc");
            sb.Append("ZWVlmzg7/LMFKOE9xKK6rbKyctvpdBIb2Gw24p3w39jDV7TvQXdXBPZPfD2ALwA2l5SUbPl8Puro6JArt7W1UUtLC1f+hspPcWNXYSBIoeTkZF6gAe5hvEB5eQrM1VH5");
            sb.Append("N86eAUzEp6CEuHXAD9BBSNm8And2dpLFYvkD6CXg24cqs2BwCxFA4i5X45kZdrvdVFNTQ4AXAd4/VFkRYD3ufae6uprq6+tl2OPxyAsEGAKojvr6FGGB8s+Zr4vh7u5u");
            sb.Append("eQTA64CNuBFV1NYVsQESInxNPT091NDQwI/lLeBHuBEVvovMI4TlGZEU4e3zDgDtAHaUlpbGHFtZEebTAXrPy6uoqPgM2AXD+BMrK8L8NwH5Ue0V4jEeSgJCnJ5CGEGC");
            sb.Append("wWVEIgzizgSzAO4Fz4xxxMn5liT9Bai3qY2rr0bzAAAAAElFTkSuQmCC");
            return sb.ToString();
        }
        /// <summary>
        /// Resetuje obrázek v paměti.
        /// Následující použití property ArrowSilverRight32_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
        /// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
        /// </summary>
        public static void ArrowSilverRight32_Reset()
        {
            _ArrowSilverRight32 = null;
        }
        /// <summary>
        /// Úložiště objektu v paměti, při prvním použití ArrowSilverRight32_Direct je objekt naplněn a následně využíván.
        /// </summary>
        private static System.Drawing.Image _ArrowSilverRight32 = null;
        #endregion
        #region Image ArrowSilverUp16
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku arrow-silver-up-16.png.
        /// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
        /// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
        /// Případně je možno vyvolat metodu ArrowSilverUp16_Reset(), která zajistí regenerování obrázku z jeho definice.
        /// Bezpečnější je používání property ArrowSilverUp16, která vrací vždy nový objekt.
        /// Pro používání pro Button.Image, kde bude nastavováno Button.Enabled = false; je třeba použít property ArrowSilverUp16_FromFile.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\DavidPrac\VSProjects\ReportEditor\Reporting.Green\Pics\source\arrow-silver-up-16.png
        /// </remarks>
        public static System.Drawing.Image ArrowSilverUp16_Cached
        {
            get
            {
                if (_ArrowSilverUp16 == null) _ArrowSilverUp16 = ArrowSilverUp16;
                return _ArrowSilverUp16;
            }
        }
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku arrow-silver-up-16.png.
        /// Nelze používat jako Image pro Buttony, kde bude nastavováno Enabled = false (pak dojde k chybě .NET: Ot of memory).
        /// Pak je třeba použít Image ArrowSilverUp16_FromFile.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití ArrowSilverUp16_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property ArrowSilverUp16_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\DavidPrac\VSProjects\ReportEditor\Reporting.Green\Pics\source\arrow-silver-up-16.png
        /// </remarks>
        public static System.Drawing.Image ArrowSilverUp16 { get { return _ImageCreateFrom(_ArrowSilverUp16_string, null); } }
        /// <summary>
        /// Vrátí obrázek, načtený ze souboru arrow-silver-up-16.png.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití ArrowSilverUp16_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property ArrowSilverUp16_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\DavidPrac\VSProjects\ReportEditor\Reporting.Green\Pics\source\arrow-silver-up-16.png
        /// </remarks>
        public static System.Drawing.Image ArrowSilverUp16_FromFile { get { return _ImageCreateFrom(_ArrowSilverUp16_string, "arrow-silver-up-16.png"); } }
        /// <summary>
        /// Vygeneruje a vrátí string, který definuje obsah souboru ArrowSilverUp16
        /// </summary>
        /// <returns></returns>
        private static string _ArrowSilverUp16_string()
        {
            System.Text.StringBuilder sb = new System.Text.StringBuilder(744);
            sb.Append("iVBORw0KGgoAAAANSUhEUgAAABAAAAAICAYAAADwdn+XAAAABGdBTUEAAK/INwWK6QAAAAlwSFlzAAAOwgAADsIBFShKgAAAAA10RVh0U291cmNlAE51dm9sYaxPNfEA");
            sb.Append("AAAadEVYdFNvZnR3YXJlAFBhaW50Lk5FVCB2My41LjExR/NCNwAAAY9JREFUKFNVkTtMwlAUhm8TI3Eyju5FBmihPMMbmvAYgImQwMAAZSCUlxhY2EgIg1tHJiMrMnVh");
            sb.Append("Mi7EwcGho3ExbA4OjUZNjufeoYbh9Jzk5v/+/5wS0zSJy+UiPM9zdrudo7PH4yGiKB5JkqQGg8GrSCRiwyK0wuEwh52Lx+NMyz5Op5M4HA7WvV4vBXI4a4PBADqdDgQC");
            sb.Append("gZtoNHqcSCRILBYjOLNuAdxuN3P1+XwEXU9QfDudTmGz2cBkMoFyuQzoeoeup7Isk3Q6TWi3AFRInVFsQ5C+WCxgu93CcDiEWq0G3W4X6vU6JJPJe6wzKs7lcocAQRDO");
            sb.Append("/X7/g6ZpsNvtYD6fQ7FYhFKpBL1eD/r9PiiKAih+SqVSfDab/Qeg6wXGe1ytVmAYBiyXSxY7FApd466zVqvFAKPRCFRVhXw+/5zJZCQLgDsZuq7Dfr+H9XoNlUoFMM2M");
            sb.Append("HopeHvu4Wq3+NptNBqGrFQqFVwuAsV7a7fZPo9H4wtgf+OsusQ4ujrEVdH7H9080+MbV3kzTJH/7Z8/mwR4SzgAAAABJRU5ErkJggg==");
            return sb.ToString();
        }
        /// <summary>
        /// Resetuje obrázek v paměti.
        /// Následující použití property ArrowSilverUp16_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
        /// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
        /// </summary>
        public static void ArrowSilverUp16_Reset()
        {
            _ArrowSilverUp16 = null;
        }
        /// <summary>
        /// Úložiště objektu v paměti, při prvním použití ArrowSilverUp16_Direct je objekt naplněn a následně využíván.
        /// </summary>
        private static System.Drawing.Image _ArrowSilverUp16 = null;
        #endregion
        #region Image ArrowSilverUp24
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku arrow-silver-up-24.png.
        /// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
        /// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
        /// Případně je možno vyvolat metodu ArrowSilverUp24_Reset(), která zajistí regenerování obrázku z jeho definice.
        /// Bezpečnější je používání property ArrowSilverUp24, která vrací vždy nový objekt.
        /// Pro používání pro Button.Image, kde bude nastavováno Button.Enabled = false; je třeba použít property ArrowSilverUp24_FromFile.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\DavidPrac\VSProjects\ReportEditor\Reporting.Green\Pics\source\arrow-silver-up-24.png
        /// </remarks>
        public static System.Drawing.Image ArrowSilverUp24_Cached
        {
            get
            {
                if (_ArrowSilverUp24 == null) _ArrowSilverUp24 = ArrowSilverUp24;
                return _ArrowSilverUp24;
            }
        }
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku arrow-silver-up-24.png.
        /// Nelze používat jako Image pro Buttony, kde bude nastavováno Enabled = false (pak dojde k chybě .NET: Ot of memory).
        /// Pak je třeba použít Image ArrowSilverUp24_FromFile.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití ArrowSilverUp24_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property ArrowSilverUp24_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\DavidPrac\VSProjects\ReportEditor\Reporting.Green\Pics\source\arrow-silver-up-24.png
        /// </remarks>
        public static System.Drawing.Image ArrowSilverUp24 { get { return _ImageCreateFrom(_ArrowSilverUp24_string, null); } }
        /// <summary>
        /// Vrátí obrázek, načtený ze souboru arrow-silver-up-24.png.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití ArrowSilverUp24_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property ArrowSilverUp24_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\DavidPrac\VSProjects\ReportEditor\Reporting.Green\Pics\source\arrow-silver-up-24.png
        /// </remarks>
        public static System.Drawing.Image ArrowSilverUp24_FromFile { get { return _ImageCreateFrom(_ArrowSilverUp24_string, "arrow-silver-up-24.png"); } }
        /// <summary>
        /// Vygeneruje a vrátí string, který definuje obsah souboru ArrowSilverUp24
        /// </summary>
        /// <returns></returns>
        private static string _ArrowSilverUp24_string()
        {
            System.Text.StringBuilder sb = new System.Text.StringBuilder(1172);
            sb.Append("iVBORw0KGgoAAAANSUhEUgAAABgAAAAMCAYAAAB4MH11AAAABGdBTUEAAK/INwWK6QAAAAlwSFlzAAAOwgAADsIBFShKgAAAAA10RVh0U291cmNlAE51dm9sYaxPNfEA");
            sb.Append("AAAadEVYdFNvZnR3YXJlAFBhaW50Lk5FVCB2My41LjExR/NCNwAAAtJJREFUOE+NVF1ImlEYPs4VbCyq5RyId+mIfqzUzH7sx9IKy5wWmanQNEJTyxvBizEoL9qFCEZj");
            sb.Append("F0E33oxAGLTZdlEXsSF4vYvtqovBxhiDDTYWFGfP+/GJbdC2B17O4Xznfd6/53ysjKamJmGVyWRSuVwuVSgUUqVSKWlvb2c6nY7sOszU1dVlNhgMNUajkWFl3d3dEpxJ");
            sb.Append("9Xq9YCqVivX39wtcv6Gzs5O1traylpYWwdra2lhHRweDE9NqtbW9vb3hubm5Nx6P553JZEogQAMRkfX19QkrGb6xoaEhkfUvQGZMo9EwVFDf09OTDAaD73d2dvj6+jqf");
            sb.Append("np7+BKIUzm//N+FFwJE1NzdTVUpk9TAWi33J5XI8nU7zUCjEl5eX+czMzDcQP8J3FapjZrNZ9P4H0A6hXbA7o6Ojj5PJ5Nd8Ps+3t7d5OBzmPp+PBwIBYe92u79bLJbc");
            sb.Append("4OCgBibBfZHlEhAxhkSD1Vit1iepVOpHoVDgu7u7PJFIUNanDofj59LSklBJJBLhfr//dHx8/BmqMQwPD19BQJHtDxA5hivFapqamnqZzWbPjo6O+N7eHt/Y2OCzs7Of");
            sb.Append("0e8MSDYXFxc/rq2tCUFWV1eponP4HKMCK1pVNTY2JrJeAIilkJ1lfn7+GBmflUolfnBwwDOZDLXiw8DAwH30+hYUU48s416v92RlZUUIEo/HaT13uVwlVHMXAapE2gog");
            sb.Append("ywY45mmQh4eHfH9/n29tbXEEPMEgYyCvIzmKkrwxMjJyDy17u7CwwFERj0ajnFpnt9tfoL1ykbYCDLcGg3oAp1fQehFZFycnJ5+DzAPJXiNllUHSREXVCGJHxk9tNlsR");
            sb.Append("0i06nc7X8NnEWa14tQIQ0cusw8NqhKmxV+MxKZFxNZETaRmYg6B99PwqTIHK1chajdY0TkxM3ERAiXi1AiqdHheeffkXwEjfFPgykGLIQC4YMmcIwBBAvMHYLwbLEMXx");
            sb.Append("puFiAAAAAElFTkSuQmCC");
            return sb.ToString();
        }
        /// <summary>
        /// Resetuje obrázek v paměti.
        /// Následující použití property ArrowSilverUp24_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
        /// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
        /// </summary>
        public static void ArrowSilverUp24_Reset()
        {
            _ArrowSilverUp24 = null;
        }
        /// <summary>
        /// Úložiště objektu v paměti, při prvním použití ArrowSilverUp24_Direct je objekt naplněn a následně využíván.
        /// </summary>
        private static System.Drawing.Image _ArrowSilverUp24 = null;
        #endregion
        #region Image ArrowSilverUp32
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku arrow-silver-up-32.png.
        /// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
        /// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
        /// Případně je možno vyvolat metodu ArrowSilverUp32_Reset(), která zajistí regenerování obrázku z jeho definice.
        /// Bezpečnější je používání property ArrowSilverUp32, která vrací vždy nový objekt.
        /// Pro používání pro Button.Image, kde bude nastavováno Button.Enabled = false; je třeba použít property ArrowSilverUp32_FromFile.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\DavidPrac\VSProjects\ReportEditor\Reporting.Green\Pics\source\arrow-silver-up-32.png
        /// </remarks>
        public static System.Drawing.Image ArrowSilverUp32_Cached
        {
            get
            {
                if (_ArrowSilverUp32 == null) _ArrowSilverUp32 = ArrowSilverUp32;
                return _ArrowSilverUp32;
            }
        }
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku arrow-silver-up-32.png.
        /// Nelze používat jako Image pro Buttony, kde bude nastavováno Enabled = false (pak dojde k chybě .NET: Ot of memory).
        /// Pak je třeba použít Image ArrowSilverUp32_FromFile.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití ArrowSilverUp32_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property ArrowSilverUp32_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\DavidPrac\VSProjects\ReportEditor\Reporting.Green\Pics\source\arrow-silver-up-32.png
        /// </remarks>
        public static System.Drawing.Image ArrowSilverUp32 { get { return _ImageCreateFrom(_ArrowSilverUp32_string, null); } }
        /// <summary>
        /// Vrátí obrázek, načtený ze souboru arrow-silver-up-32.png.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití ArrowSilverUp32_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property ArrowSilverUp32_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\DavidPrac\VSProjects\ReportEditor\Reporting.Green\Pics\source\arrow-silver-up-32.png
        /// </remarks>
        public static System.Drawing.Image ArrowSilverUp32_FromFile { get { return _ImageCreateFrom(_ArrowSilverUp32_string, "arrow-silver-up-32.png"); } }
        /// <summary>
        /// Vygeneruje a vrátí string, který definuje obsah souboru ArrowSilverUp32
        /// </summary>
        /// <returns></returns>
        private static string _ArrowSilverUp32_string()
        {
            System.Text.StringBuilder sb = new System.Text.StringBuilder(1412);
            sb.Append("iVBORw0KGgoAAAANSUhEUgAAACAAAAAQCAYAAAB3AH1ZAAAABGdBTUEAAK/INwWK6QAAAAlwSFlzAAAOwgAADsIBFShKgAAAAA10RVh0U291cmNlAE51dm9sYaxPNfEA");
            sb.Append("AAAadEVYdFNvZnR3YXJlAFBhaW50Lk5FVCB2My41LjExR/NCNwAAA4VJREFUSEvNlV1Ik2EUx18zwxT6IPCmbiTqovzW6fyaujm316/plJjTC7cJS3R+LWXDC4WEcnSj");
            sb.Append("iSAYiHg30PBWRn4RRo5ddZFd2UUXSmRDKNA6/c/DuxFZDcOLDhyesT3v8/uf/znPO+nXSE9Pl9LS0kTy54yMDCkzM1PKzs6WcnJyxJ6CggJJrVbH5+fnpyJvFRYWJhQV");
            sb.Append("FYnfeE9xcbHIkpKSaJaWlkoajUbsiRkMjYCzsrIEnJOD4Tj8vEqlsgD8EocH8d19rIkM4ohAI3kq+J+CK0K1XHlSXl6eEwd+GB4eppGREaqoqPgEMV7ALjGwrKxMeeoM");
            sb.Append("g+GAJOfm5nrKy8v3fT4frays0NTUFNlsNhYRhsjHEHCNKz6zYMtRMa8pgPuMRuPh9PQ0BQIBGh8fJ4fDQS6XS6x6vf4rBMzCnVR2AaKUU/4xULEEqIR+X8f6zGQyfVlY");
            sb.Append("WKDV1VViBzo6OqitrU040NvbS52dnSTL8hEceA4Bt9mJyspK5bRTBlvOAwj4XTjgB+h4eXmZ1tbWaGJiggYGBqICWltboyLYjYaGhu9oUwCp9vv9pxfBlTc1NbH14KsC");
            sb.Append("drv9G1u+sbFBMzMzNDY2Jqqtqqo61ul0R2x/V1cXYZ8Q0d/fT83NzaTVaoNIHfadMxgMyukxgitH7+JguQF9D3GlW1tbtLm5SfPz8zQ5OUk9PT0E8CGG7il6/gitOeDb");
            sb.Append("0NfXF3VicHCQrFYrofp3yHsQEB9TBK6YeMHgZdKIg9+Ojo5SKBQSAhYXF2lubo7cbjfDeeIfYs8V9DoZq7u+vn6PoQxnR1iMx+Oh9vZ2wuC+x4DasCZiRhTab4LhsNwK");
            sb.Append("B3a50p2dHQoGg2LiWQC7AeA+4A8w6UkAixcM9l/Aagdgl1vR3d0dFcHvCqfTSbW1tXtwwAUBCQruZMD+y8iA1+ul7e1tWl9fF3d9aWlJHAb4LuAOTPdFhkeCRaDXCRg6");
            sb.Append("MyBvLBYLtbS0iOpZzNDQkGgN4K8g8qry2MkAPBF9f4JN+2azOYxpDjc2Nobr6uo+A/oacBNA8T/DI8F3Hs/EoT0a9PwFzjgAMIzKxTmYk4/V1dWz+C5ZeeRkwH5uQwpW");
            sb.Append("LVKGIBmCZNwKI6B3IOK38EgALtXU1Ejo902kAdMvc8IVGYL0EHCDf/9r8CDy24+TP/OVROXRP5ZYwXcecJGASzz5gEs8fBAg8j8KSfoBLP26OEMYTOgAAAAASUVORK5C");
            sb.Append("YII=");
            return sb.ToString();
        }
        /// <summary>
        /// Resetuje obrázek v paměti.
        /// Následující použití property ArrowSilverUp32_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
        /// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
        /// </summary>
        public static void ArrowSilverUp32_Reset()
        {
            _ArrowSilverUp32 = null;
        }
        /// <summary>
        /// Úložiště objektu v paměti, při prvním použití ArrowSilverUp32_Direct je objekt naplněn a následně využíván.
        /// </summary>
        private static System.Drawing.Image _ArrowSilverUp32 = null;
        #endregion
        #region Image ArrowVioletDown16
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku arrow-violet-down-16.png.
        /// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
        /// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
        /// Případně je možno vyvolat metodu ArrowVioletDown16_Reset(), která zajistí regenerování obrázku z jeho definice.
        /// Bezpečnější je používání property ArrowVioletDown16, která vrací vždy nový objekt.
        /// Pro používání pro Button.Image, kde bude nastavováno Button.Enabled = false; je třeba použít property ArrowVioletDown16_FromFile.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\DavidPrac\VSProjects\ReportEditor\Reporting.Green\Pics\source\arrow-violet-down-16.png
        /// </remarks>
        public static System.Drawing.Image ArrowVioletDown16_Cached
        {
            get
            {
                if (_ArrowVioletDown16 == null) _ArrowVioletDown16 = ArrowVioletDown16;
                return _ArrowVioletDown16;
            }
        }
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku arrow-violet-down-16.png.
        /// Nelze používat jako Image pro Buttony, kde bude nastavováno Enabled = false (pak dojde k chybě .NET: Ot of memory).
        /// Pak je třeba použít Image ArrowVioletDown16_FromFile.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití ArrowVioletDown16_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property ArrowVioletDown16_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\DavidPrac\VSProjects\ReportEditor\Reporting.Green\Pics\source\arrow-violet-down-16.png
        /// </remarks>
        public static System.Drawing.Image ArrowVioletDown16 { get { return _ImageCreateFrom(_ArrowVioletDown16_string, null); } }
        /// <summary>
        /// Vrátí obrázek, načtený ze souboru arrow-violet-down-16.png.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití ArrowVioletDown16_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property ArrowVioletDown16_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\DavidPrac\VSProjects\ReportEditor\Reporting.Green\Pics\source\arrow-violet-down-16.png
        /// </remarks>
        public static System.Drawing.Image ArrowVioletDown16_FromFile { get { return _ImageCreateFrom(_ArrowVioletDown16_string, "arrow-violet-down-16.png"); } }
        /// <summary>
        /// Vygeneruje a vrátí string, který definuje obsah souboru ArrowVioletDown16
        /// </summary>
        /// <returns></returns>
        private static string _ArrowVioletDown16_string()
        {
            System.Text.StringBuilder sb = new System.Text.StringBuilder(836);
            sb.Append("iVBORw0KGgoAAAANSUhEUgAAABAAAAAICAYAAADwdn+XAAAABGdBTUEAAK/INwWK6QAAAAlwSFlzAAAOwgAADsIBFShKgAAAAA10RVh0U291cmNlAE51dm9sYaxPNfEA");
            sb.Append("AAAadEVYdFNvZnR3YXJlAFBhaW50Lk5FVCB2My41LjExR/NCNwAAAdRJREFUKFNjOHPmDEO9VPXlfsvun/36vd+65Ttfdwq2pEwU6mWYKTKdYZ7oPCCezTBfdF7YIvFF");
            sb.Append("LxaJLfm5TGH5ryVSy26B9IINaFaofbC1d+v/fauP/19XuO3/NPUpfycIdVVADJgLxHMyl2ou+75MacX/Zbqr/q8wW/t/qfSyF3AD6vjLDbtUmy5ubtnyf9fcw//Xxm7+");
            sb.Append("P1dt7v8ZwtOa5knMq1hpvuLvSqPVYM3LQLTMsttLxJZaww2oF6hiaOKvUumT6Di7sWjj/x3d+/+vcFn3f4HMwv+LFZf8W2kA1KQF1Aw0YInksqtLxZboAw0A6wUTtfwV");
            sb.Append("DB2CTQx9Ql0CU8UmHNiUten/tro9/5frADWILf2/VH0l2IClEktPAfmyi4GaF4otQhhQwJfFUMKbxdAt1MEwR2QW3yzhaes2xQINKdr1fxnIdrWV/5eKL925SHyZ2GKx");
            sb.Append("xQwzgGHTDwxkuAG5vGkMYRweDBnccQzV/KUMi0TnsS8WnTd/Q9Cm/2uc1v9fLLpw9RKxZdwThScALelkaBaoZ+gR6kIYkMeXzhDN6ccQxenDEMcVwtAkWMcAdCYb0K/1");
            sb.Append("SyWXtgM1c/YBbawDhlWjQC1DO9C7vULdQL1nGADX1vUIQm1eAAAAAABJRU5ErkJggg==");
            return sb.ToString();
        }
        /// <summary>
        /// Resetuje obrázek v paměti.
        /// Následující použití property ArrowVioletDown16_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
        /// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
        /// </summary>
        public static void ArrowVioletDown16_Reset()
        {
            _ArrowVioletDown16 = null;
        }
        /// <summary>
        /// Úložiště objektu v paměti, při prvním použití ArrowVioletDown16_Direct je objekt naplněn a následně využíván.
        /// </summary>
        private static System.Drawing.Image _ArrowVioletDown16 = null;
        #endregion
        #region Image ArrowVioletDown24
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku arrow-violet-down-24.png.
        /// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
        /// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
        /// Případně je možno vyvolat metodu ArrowVioletDown24_Reset(), která zajistí regenerování obrázku z jeho definice.
        /// Bezpečnější je používání property ArrowVioletDown24, která vrací vždy nový objekt.
        /// Pro používání pro Button.Image, kde bude nastavováno Button.Enabled = false; je třeba použít property ArrowVioletDown24_FromFile.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\DavidPrac\VSProjects\ReportEditor\Reporting.Green\Pics\source\arrow-violet-down-24.png
        /// </remarks>
        public static System.Drawing.Image ArrowVioletDown24_Cached
        {
            get
            {
                if (_ArrowVioletDown24 == null) _ArrowVioletDown24 = ArrowVioletDown24;
                return _ArrowVioletDown24;
            }
        }
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku arrow-violet-down-24.png.
        /// Nelze používat jako Image pro Buttony, kde bude nastavováno Enabled = false (pak dojde k chybě .NET: Ot of memory).
        /// Pak je třeba použít Image ArrowVioletDown24_FromFile.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití ArrowVioletDown24_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property ArrowVioletDown24_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\DavidPrac\VSProjects\ReportEditor\Reporting.Green\Pics\source\arrow-violet-down-24.png
        /// </remarks>
        public static System.Drawing.Image ArrowVioletDown24 { get { return _ImageCreateFrom(_ArrowVioletDown24_string, null); } }
        /// <summary>
        /// Vrátí obrázek, načtený ze souboru arrow-violet-down-24.png.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití ArrowVioletDown24_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property ArrowVioletDown24_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\DavidPrac\VSProjects\ReportEditor\Reporting.Green\Pics\source\arrow-violet-down-24.png
        /// </remarks>
        public static System.Drawing.Image ArrowVioletDown24_FromFile { get { return _ImageCreateFrom(_ArrowVioletDown24_string, "arrow-violet-down-24.png"); } }
        /// <summary>
        /// Vygeneruje a vrátí string, který definuje obsah souboru ArrowVioletDown24
        /// </summary>
        /// <returns></returns>
        private static string _ArrowVioletDown24_string()
        {
            System.Text.StringBuilder sb = new System.Text.StringBuilder(1284);
            sb.Append("iVBORw0KGgoAAAANSUhEUgAAABgAAAAMCAYAAAB4MH11AAAABGdBTUEAAK/INwWK6QAAAAlwSFlzAAAOwgAADsIBFShKgAAAAA10RVh0U291cmNlAE51dm9sYaxPNfEA");
            sb.Append("AAAadEVYdFNvZnR3YXJlAFBhaW50Lk5FVCB2My41LjExR/NCNwAAAyZJREFUOE+Nk11IU2EYx581Kal9nTN3Zll+lZqWWQQV3QQJQUWSENIXBCYRkVnkV9PW1JPmmstG");
            sb.Append("nWojd3Y+3s25rbS0DFH6uMnuopu6CKqb6KKLCCVC357VWUYR9Yc/hwMPv//zPjwPpNTMOMBhboRWtNPsgHaLE3jGBZ0sr1X8qT4uCEEuBBIng8ypoPw00Sp+UcP3gAZD");
            sb.Append("i7k+12luym+zOPI7LM5MnmnTe1k3+Kw+rRKgC/+DCO+z9elDXMguc0oBgpPOQ5skDPlDzaZTi5yco6GrkJ+4uLL7cU+h58nFbHe8m+3c5Wb4+T62V6vEzm19cDPjRprI");
            sb.Append("ieUiJ0UkTplUlpCnchZ5qGQSJ4YYtdI5NZlqM/hc16BcE6J3LozQhGOYkoPRWaFEeHUpw3P4Mus1CFYB4QG0P13MFKvkfPW5nENm1ZwwJWuilKyKUjWLjKmcYtewc3KY");
            sb.Append("TqW12VorfJu9z2633p4Z8z+kI+fGaH9VggaK/W8E7sppDLBggEHMCh4hpeRlZB1CC/tpuGyAhtcOzKp54ReyXd2PL5ivYeeEAXDOVJ/GW5zbfGXeR4m6xMxozzgdqhul");
            sb.Append("0e1xGiwU3we4QKe4RHRG1kfeRjfFaLio/0fnpdFZNZs8Q3Aldr8Avxr1N7nMZwDnrXMzHRuFIt9wrDr25T4/RgerR2h48wAN5UrTUrY8FVmNXSfhpQgviX5Vl5JxhG5B");
            sb.Append("6/8KT6mTaQcP06HrZT2l/oJrSmxv7PNIywOa2DNESTFClxGq5OLMcd44nmmc+S2EbsDO5/0TnpKH7YbG9EoQrL7lN3MCV+MV8U/Dp0dpYucgJQUYUoLwFZEpZTGRELoq");
            sb.Append("uff/DU8pufc9zHkIWAW7tFTsiJUnPtw9fp/Gd2BIfuSjmkm8CM2WbcH/g7esGIJa4xGoMRyAQwuroHrRPqg3nYDrNgEBkpVkkYbYpvjr6Mb4O9x5V3IV8cDAy/bgxbfj");
            sb.Append("aHlws134ejd4rV6N+ouOG2rgqP0wVOjLdFv1K3Xl+mLdxL1JOGashhB2iUAjeid2uxvNyJwELsvZ70fXaDqpa0Y3Go/pri/2Qy+bCgD4BsAladiOpWncAAAAAElFTkSu");
            sb.Append("QmCC");
            return sb.ToString();
        }
        /// <summary>
        /// Resetuje obrázek v paměti.
        /// Následující použití property ArrowVioletDown24_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
        /// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
        /// </summary>
        public static void ArrowVioletDown24_Reset()
        {
            _ArrowVioletDown24 = null;
        }
        /// <summary>
        /// Úložiště objektu v paměti, při prvním použití ArrowVioletDown24_Direct je objekt naplněn a následně využíván.
        /// </summary>
        private static System.Drawing.Image _ArrowVioletDown24 = null;
        #endregion
        #region Image ArrowVioletDown32
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku arrow-violet-down-32.png.
        /// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
        /// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
        /// Případně je možno vyvolat metodu ArrowVioletDown32_Reset(), která zajistí regenerování obrázku z jeho definice.
        /// Bezpečnější je používání property ArrowVioletDown32, která vrací vždy nový objekt.
        /// Pro používání pro Button.Image, kde bude nastavováno Button.Enabled = false; je třeba použít property ArrowVioletDown32_FromFile.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\DavidPrac\VSProjects\ReportEditor\Reporting.Green\Pics\source\arrow-violet-down-32.png
        /// </remarks>
        public static System.Drawing.Image ArrowVioletDown32_Cached
        {
            get
            {
                if (_ArrowVioletDown32 == null) _ArrowVioletDown32 = ArrowVioletDown32;
                return _ArrowVioletDown32;
            }
        }
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku arrow-violet-down-32.png.
        /// Nelze používat jako Image pro Buttony, kde bude nastavováno Enabled = false (pak dojde k chybě .NET: Ot of memory).
        /// Pak je třeba použít Image ArrowVioletDown32_FromFile.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití ArrowVioletDown32_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property ArrowVioletDown32_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\DavidPrac\VSProjects\ReportEditor\Reporting.Green\Pics\source\arrow-violet-down-32.png
        /// </remarks>
        public static System.Drawing.Image ArrowVioletDown32 { get { return _ImageCreateFrom(_ArrowVioletDown32_string, null); } }
        /// <summary>
        /// Vrátí obrázek, načtený ze souboru arrow-violet-down-32.png.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití ArrowVioletDown32_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property ArrowVioletDown32_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\DavidPrac\VSProjects\ReportEditor\Reporting.Green\Pics\source\arrow-violet-down-32.png
        /// </remarks>
        public static System.Drawing.Image ArrowVioletDown32_FromFile { get { return _ImageCreateFrom(_ArrowVioletDown32_string, "arrow-violet-down-32.png"); } }
        /// <summary>
        /// Vygeneruje a vrátí string, který definuje obsah souboru ArrowVioletDown32
        /// </summary>
        /// <returns></returns>
        private static string _ArrowVioletDown32_string()
        {
            System.Text.StringBuilder sb = new System.Text.StringBuilder(1592);
            sb.Append("iVBORw0KGgoAAAANSUhEUgAAACAAAAAQCAYAAAB3AH1ZAAAABGdBTUEAAK/INwWK6QAAAAlwSFlzAAAOwgAADsIBFShKgAAAAA10RVh0U291cmNlAE51dm9sYaxPNfEA");
            sb.Append("AAAadEVYdFNvZnR3YXJlAFBhaW50Lk5FVCB2My41LjExR/NCNwAABAtJREFUSEvNlW1oW1UYx09ZSZ0tTXqT3C5tzeZgm2660dHFlznErXOgE6E6kYmyTc1ERLBaV5I1");
            sb.Append("sWl606RtiLWmNEnzcnPvyVuTlLQ0tmvTOvw2/eaH+kmlIANXFZniG3t8TnaDg7JZZYJ/eDjnhnPye97OOeR/J4v6XWJFs2ksxK6xEkeDjTgbeonAOYmHcyurbq0IHyUx");
            sb.Append("XiQiL5E4L5dNUsZbisHR1BZ118M96nNHbWpLe6/G2t6nsR8WuL5tdtVTxKv1KqvXK6wPkyjC0YEmdOAIOnAcoU8i/BjaIZzrmCM3FYJrrOruHkezbVXY6lhzGfvX3EbX");
            sb.Append("mqfF/a2Lc17wcK5DA9qhqhHt+8qOvxTmIySkcSE8sg+dyIt8/AoCf4o3ylfjBvoD2jf4PYwObFa2rBemXn1e070c6BiDOf88TDuLkDs/C9nOaQgeDMGw3rPi5YZO+LS+");
            sb.Append("ar/Or+xikUdIkA9XRfjwkZhBvCRtpxBvkkEyUqC705A0ZYHemwZ04FN0gFO2rRfWvRrttYEdjsuZ7hR8nPkEFscuQtG1BPnOIkQficEI7/sKM/DKqM5fM64PlOEhPrIJ");
            sb.Append("098hNoufJ9oQuDcN8tYE0Ptx/lAOEq0ZoHdhFnjZiqZScOvFGs/RYFc5NNZTAy19q9QswTK9CPPeJZjpmoe8eRbEgxL4t3y45tf630EH7kSwKqyfOC1uE1czj2Uh1Yaw");
            sb.Append("CvzBXHmUm+gVjPxthNehKbSb6D1ND3FznmqhwfHsoEFYkZ4ToRRahgueJSiYi5A9UQDJRCFoCH4f1AUFdMAS3xm/nDueh/SBSZBZ2vekIWHC+T0pkAz0a4S/KvH0Dgb/");
            sb.Append("WweYBE4gw1uCVYOc66hXN/iZ+ETs2oK/BHNCCXInZyDz+BTIexMQaYr+HmuM/ZZsTUN6P0aqwFMHsOY7UqzmKwh/RuTlTRsC3yh25r0tKeLjvKYRnW9BfDR6bX5oAeZd");
            sb.Append("Jcg+XYDk/kmgu5JYa8pSfL3h7sPI2e/bkwx+CeHtYiOt+sfwirycl7g1NjKqHdnl145mRVPs11n7HMz1l2Dy2FQZJFXgLO37Mqz5/kDwIlqbX3USLyCq/Nu/FDvzH2h9");
            sb.Append("JKALGAO68VB8j/jLbNdHMOcsQeZwDtOODYdHjbLON1IGz2PEu3HcWL03qnHdOJngw9qoPizQnfKP02dnoehYhGxHARKYermZ/ozQMYQabzuciZ35Cf0E3u/x+jgvWujd");
            sb.Append("ie8KL87AFDYlHrurCPUgVPufwG/U9UeG1si8ZKZN9Au8YL5E6Dmsde1tAb9V/wZ5ve4MOVP7Ajld+zx5GUdz3UvkbN0p0ln/ZnkNAyFQheBWtAfwezOLvKJefEHxQsNX");
            sb.Append("1EFcXD/eKwIZ5DxkmBtUVlREyJ/KhCEcuuN1NAAAAABJRU5ErkJggg==");
            return sb.ToString();
        }
        /// <summary>
        /// Resetuje obrázek v paměti.
        /// Následující použití property ArrowVioletDown32_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
        /// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
        /// </summary>
        public static void ArrowVioletDown32_Reset()
        {
            _ArrowVioletDown32 = null;
        }
        /// <summary>
        /// Úložiště objektu v paměti, při prvním použití ArrowVioletDown32_Direct je objekt naplněn a následně využíván.
        /// </summary>
        private static System.Drawing.Image _ArrowVioletDown32 = null;
        #endregion
        #region Image ArrowVioletLeft16
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku arrow-violet-left-16.png.
        /// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
        /// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
        /// Případně je možno vyvolat metodu ArrowVioletLeft16_Reset(), která zajistí regenerování obrázku z jeho definice.
        /// Bezpečnější je používání property ArrowVioletLeft16, která vrací vždy nový objekt.
        /// Pro používání pro Button.Image, kde bude nastavováno Button.Enabled = false; je třeba použít property ArrowVioletLeft16_FromFile.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\DavidPrac\VSProjects\ReportEditor\Reporting.Green\Pics\source\arrow-violet-left-16.png
        /// </remarks>
        public static System.Drawing.Image ArrowVioletLeft16_Cached
        {
            get
            {
                if (_ArrowVioletLeft16 == null) _ArrowVioletLeft16 = ArrowVioletLeft16;
                return _ArrowVioletLeft16;
            }
        }
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku arrow-violet-left-16.png.
        /// Nelze používat jako Image pro Buttony, kde bude nastavováno Enabled = false (pak dojde k chybě .NET: Ot of memory).
        /// Pak je třeba použít Image ArrowVioletLeft16_FromFile.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití ArrowVioletLeft16_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property ArrowVioletLeft16_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\DavidPrac\VSProjects\ReportEditor\Reporting.Green\Pics\source\arrow-violet-left-16.png
        /// </remarks>
        public static System.Drawing.Image ArrowVioletLeft16 { get { return _ImageCreateFrom(_ArrowVioletLeft16_string, null); } }
        /// <summary>
        /// Vrátí obrázek, načtený ze souboru arrow-violet-left-16.png.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití ArrowVioletLeft16_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property ArrowVioletLeft16_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\DavidPrac\VSProjects\ReportEditor\Reporting.Green\Pics\source\arrow-violet-left-16.png
        /// </remarks>
        public static System.Drawing.Image ArrowVioletLeft16_FromFile { get { return _ImageCreateFrom(_ArrowVioletLeft16_string, "arrow-violet-left-16.png"); } }
        /// <summary>
        /// Vygeneruje a vrátí string, který definuje obsah souboru ArrowVioletLeft16
        /// </summary>
        /// <returns></returns>
        private static string _ArrowVioletLeft16_string()
        {
            System.Text.StringBuilder sb = new System.Text.StringBuilder(828);
            sb.Append("iVBORw0KGgoAAAANSUhEUgAAAAgAAAAQCAYAAAArij59AAAABGdBTUEAAK/INwWK6QAAAAlwSFlzAAAOwgAADsIBFShKgAAAAA10RVh0U291cmNlAE51dm9sYaxPNfEA");
            sb.Append("AAAadEVYdFNvZnR3YXJlAFBhaW50Lk5FVCB2My41LjExR/NCNwAAAc9JREFUKFNjOHPmDF7MkMWThIKzgTiPLzU/TybjfxJfVDVDGk8cQxp3LEM6TyyQjmFI4grOaPNq");
            sb.Append("+L+oZtn/dNHYAwxJ3FEMiVxhQIkwhnjOgJhyw4Lf21Yf+r+8bt3/DP64fWAFSVwRDAlcQd5FWpkf107Z/n/r5EP/p/nN+J/Jm7AArCCO098sWynh2Yqejf831Oz7P8dr");
            sb.Append("3v9coZSrQDfJM8RzBWumSUXdXNK4+v/anF3/Z5vN+58nkvYwkydBp4Qvj4EhTSz2woKyZf9Xx277P1th7v8C/qxnQJ8YZvOmMFTxlTAwZMok3Zjrt+j/YqWV/2dIzPxf");
            sb.Append("IpH3sJQvT61OoIqhjr+SAei4MJMc/uSHs7Tm/l+stur/fKv5/2vky25V85epNAs2MDAkc0cDwyLWuUKs6O08vUX/l2it+j/PdN7/Rsnak22CTZJAX0QzZPAkMuTzZkQ2");
            sb.Append("StZ9X2i47P8SjVX/p0lN+w9UMAPoi3BwaObxpjOU8eWndcl2/F9isfr/PKVF/7uEOvYxlPIVMpTzFzPUCFQwgBzWKFBTOkVl6v8FBkv+TxDtO8DQJtQCxq1CTQytgs0M");
            sb.Append("LYJNDF3CbTWTpSb9nyw6qQVrFCPwGQYAj8XcsKvDmKsAAAAASUVORK5CYII=");
            return sb.ToString();
        }
        /// <summary>
        /// Resetuje obrázek v paměti.
        /// Následující použití property ArrowVioletLeft16_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
        /// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
        /// </summary>
        public static void ArrowVioletLeft16_Reset()
        {
            _ArrowVioletLeft16 = null;
        }
        /// <summary>
        /// Úložiště objektu v paměti, při prvním použití ArrowVioletLeft16_Direct je objekt naplněn a následně využíván.
        /// </summary>
        private static System.Drawing.Image _ArrowVioletLeft16 = null;
        #endregion
        #region Image ArrowVioletLeft24
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku arrow-violet-left-24.png.
        /// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
        /// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
        /// Případně je možno vyvolat metodu ArrowVioletLeft24_Reset(), která zajistí regenerování obrázku z jeho definice.
        /// Bezpečnější je používání property ArrowVioletLeft24, která vrací vždy nový objekt.
        /// Pro používání pro Button.Image, kde bude nastavováno Button.Enabled = false; je třeba použít property ArrowVioletLeft24_FromFile.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\DavidPrac\VSProjects\ReportEditor\Reporting.Green\Pics\source\arrow-violet-left-24.png
        /// </remarks>
        public static System.Drawing.Image ArrowVioletLeft24_Cached
        {
            get
            {
                if (_ArrowVioletLeft24 == null) _ArrowVioletLeft24 = ArrowVioletLeft24;
                return _ArrowVioletLeft24;
            }
        }
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku arrow-violet-left-24.png.
        /// Nelze používat jako Image pro Buttony, kde bude nastavováno Enabled = false (pak dojde k chybě .NET: Ot of memory).
        /// Pak je třeba použít Image ArrowVioletLeft24_FromFile.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití ArrowVioletLeft24_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property ArrowVioletLeft24_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\DavidPrac\VSProjects\ReportEditor\Reporting.Green\Pics\source\arrow-violet-left-24.png
        /// </remarks>
        public static System.Drawing.Image ArrowVioletLeft24 { get { return _ImageCreateFrom(_ArrowVioletLeft24_string, null); } }
        /// <summary>
        /// Vrátí obrázek, načtený ze souboru arrow-violet-left-24.png.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití ArrowVioletLeft24_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property ArrowVioletLeft24_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\DavidPrac\VSProjects\ReportEditor\Reporting.Green\Pics\source\arrow-violet-left-24.png
        /// </remarks>
        public static System.Drawing.Image ArrowVioletLeft24_FromFile { get { return _ImageCreateFrom(_ArrowVioletLeft24_string, "arrow-violet-left-24.png"); } }
        /// <summary>
        /// Vygeneruje a vrátí string, který definuje obsah souboru ArrowVioletLeft24
        /// </summary>
        /// <returns></returns>
        private static string _ArrowVioletLeft24_string()
        {
            System.Text.StringBuilder sb = new System.Text.StringBuilder(1224);
            sb.Append("iVBORw0KGgoAAAANSUhEUgAAAAwAAAAYCAYAAADOMhxqAAAABGdBTUEAAK/INwWK6QAAAAlwSFlzAAAOwgAADsIBFShKgAAAAA10RVh0U291cmNlAE51dm9sYaxPNfEA");
            sb.Append("AAAadEVYdFNvZnR3YXJlAFBhaW50Lk5FVCB2My41LjExR/NCNwAAAvlJREFUOE+tkl1IU2EYx9+ZUZxtZ9txHT8q8CvNIiEF04usmwwSujCbn3Pu7KO56dKjLbdYTpvb");
            sb.Append("nG3Oc+ZqswwnbmpqqajRFwR1EyLdBl1GBHlTILnU3s70oEgKXfS7fJ7fn/d5n/cF/50mVAu0fAIouVIg51ay1T0woSQo4xcBNVLJIxBJXC23fB/b2h0VtwpoeUSiPv6a");
            sb.Append("U5eoGiX4lflsayfXUQ0gkHKg4dWI9Ylqu7vE9cNWZPupRKsbWGUnMqQEKJFytA6TG7uK7UtPvPOQkngjalTWzCrbqHlSoEAkB9VCqa7jfNuXSdcsnO97A6nLdESLEjsD");
            sb.Append("MuRKdO4DCrSiwlxg+jTSPgnnnK/hRMsMtJ/pXNKhimpWBUCOSICGK41hZr9kyCY/DLWOwlnLK/hYPQ09hT0rZHz9Ax2POLwhR3fMrI0jQ0oLycz6dw8bBn9PG5/DsdKn");
            sb.Append("kMqj1ki8YZzZ1nFz2vSGHw1wahHJaX2K5sV9IrA2RT6DIxcmIJ1NrxrwxpdaviKnCdVxGvjqzYAMkWAaXO6nJPTqpH4OjuZNQH+aHxrE5CIjn2NETiPz4lvUIKVibYJy");
            sb.Append("kC72rYfPjsPho2HYl+SDrXjL+yahNr8mtgBYhCbWZqjllsUo+FUFJK5/Sx2j1ocywjCYOgx9OfSv26mmKQPamLWwsADuiNq2AtGXjdHw5BeN+I1FX6YfhrJGYSg7DH25");
            sb.Append("vkh7kvmRWdCa7BB1bAaiKJifWM9XxTKzXm1LNH/sPzmwERo+FYbeLHq581CHxyq04Ky+SR2PAM2oHjEISZXjiP3zQHYQhk6MwWD6EPTEu7/aRNZyVt2GRPXAgJI8s8h0");
            sb.Append("053s+jaYE9o4yZdwL+LEuv7+S1GYSwJmZswaZ+n0pvd9D+aGYSClP+LCuncPGAUt4JbAAKwiS5ITd3gDGf3LgdT+lV5xj55Vdie6eyfmSPbgbh+dQM1QYqqQbe2ODbMC");
            sb.Append("ragKuLFugQdz4XQctZ9t7c1dzMkEXIAS9wImwFb/GQD+AN9BGacGSdsjAAAAAElFTkSuQmCC");
            return sb.ToString();
        }
        /// <summary>
        /// Resetuje obrázek v paměti.
        /// Následující použití property ArrowVioletLeft24_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
        /// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
        /// </summary>
        public static void ArrowVioletLeft24_Reset()
        {
            _ArrowVioletLeft24 = null;
        }
        /// <summary>
        /// Úložiště objektu v paměti, při prvním použití ArrowVioletLeft24_Direct je objekt naplněn a následně využíván.
        /// </summary>
        private static System.Drawing.Image _ArrowVioletLeft24 = null;
        #endregion
        #region Image ArrowVioletLeft32
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku arrow-violet-left-32.png.
        /// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
        /// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
        /// Případně je možno vyvolat metodu ArrowVioletLeft32_Reset(), která zajistí regenerování obrázku z jeho definice.
        /// Bezpečnější je používání property ArrowVioletLeft32, která vrací vždy nový objekt.
        /// Pro používání pro Button.Image, kde bude nastavováno Button.Enabled = false; je třeba použít property ArrowVioletLeft32_FromFile.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\DavidPrac\VSProjects\ReportEditor\Reporting.Green\Pics\source\arrow-violet-left-32.png
        /// </remarks>
        public static System.Drawing.Image ArrowVioletLeft32_Cached
        {
            get
            {
                if (_ArrowVioletLeft32 == null) _ArrowVioletLeft32 = ArrowVioletLeft32;
                return _ArrowVioletLeft32;
            }
        }
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku arrow-violet-left-32.png.
        /// Nelze používat jako Image pro Buttony, kde bude nastavováno Enabled = false (pak dojde k chybě .NET: Ot of memory).
        /// Pak je třeba použít Image ArrowVioletLeft32_FromFile.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití ArrowVioletLeft32_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property ArrowVioletLeft32_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\DavidPrac\VSProjects\ReportEditor\Reporting.Green\Pics\source\arrow-violet-left-32.png
        /// </remarks>
        public static System.Drawing.Image ArrowVioletLeft32 { get { return _ImageCreateFrom(_ArrowVioletLeft32_string, null); } }
        /// <summary>
        /// Vrátí obrázek, načtený ze souboru arrow-violet-left-32.png.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití ArrowVioletLeft32_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property ArrowVioletLeft32_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\DavidPrac\VSProjects\ReportEditor\Reporting.Green\Pics\source\arrow-violet-left-32.png
        /// </remarks>
        public static System.Drawing.Image ArrowVioletLeft32_FromFile { get { return _ImageCreateFrom(_ArrowVioletLeft32_string, "arrow-violet-left-32.png"); } }
        /// <summary>
        /// Vygeneruje a vrátí string, který definuje obsah souboru ArrowVioletLeft32
        /// </summary>
        /// <returns></returns>
        private static string _ArrowVioletLeft32_string()
        {
            System.Text.StringBuilder sb = new System.Text.StringBuilder(1648);
            sb.Append("iVBORw0KGgoAAAANSUhEUgAAABAAAAAgCAYAAAAbifjMAAAABGdBTUEAAK/INwWK6QAAAAlwSFlzAAAOwgAADsIBFShKgAAAAA10RVh0U291cmNlAE51dm9sYaxPNfEA");
            sb.Append("AAAadEVYdFNvZnR3YXJlAFBhaW50Lk5FVCB2My41LjExR/NCNwAABDZJREFUSEvVk2tMW2UYx182YY7Tc9q+RZhs4OLMNJhVBWfGPhg3o1m2sGjiELm1tLTQQi+cUSgF");
            sb.Append("ChTobfRCW1C6gY7LGZStCzAum8kQ/WI08ZvzgzFRP6iZMcwa432P7+lOIgPZ+Gb8Jf3S5/n93+e8F/T/w8ToUa1IhVRUOVJQJcK/W4RljMgiZrfrRWpxNVWRpqLKhMoW");
            sb.Append("MNK1qIlhU+vpao1WVHldRZV2KKlSqVC+N2RVZJU0b9OJlOUNufpv3SdcoMtSf6eiSl4QWjanjtYiO+5J0YmqXtE/pPrqrHEY4pEFMOboE2SKk0Lbv9OOHciR4SGbpjxa");
            sb.Append("ixU3QhUhuDr1AVxyz4M5W5/QUOVFQutG6hgtKko7jGpEygINU/6x96QblsZX4GqUBNjngN1tSNSIFJsHkPF4+bFqumzJcbTzr9mz12Ax/D4supZhko0Du8twS0+rjgvt");
            sb.Append("d1MtKuPlPSrqjVjroebb8YFFWAyuwKzlGlxm58FT6IJ6sWbZQGv3Cco/aEUKIldJVeklQ01y86/TfbOw4H8PZmqWIK6dB1/hGTBItJ8T+Qi5FymCdgc1uV1akZKuSi/u");
            sb.Append("Nu2r/WWiIwYLgRWIV8zD9KkZ6C8MgUmq+7qe1pRYpbYUM1MvmASNqBLpaM0OZXpxk36P+se3G8eSK8dfm4PYS5ch8uwAmLF+lcg1REzlr/RdkJXTiKyqyVT+8JY2Clf8");
            sb.Append("y3CpaBa4/BgMHhgEFhtuEbmZZQwPmpk6wVpDFfW6XC0p/zRUGoFZ33WYPj4D3KOTMLx/BJpk7O/1tNZDVqWMtE4w1qGgigu0WPFFtHIELpZdgYlHLsDEbg6iOefAImn4");
            sb.Append("zcjo7BamYUeLuFEw1kFe1k41VXbalKX7KZw3ABNPxpIho9njMCgfAFtu481GxqixiVsesEtsgrWGOxeniiIvzcVi48+DeVHgDpCQXA4myT5Ejw1B68NN31gZ9pRd0rbN");
            sb.Append("Ie0UzDXwJ0Eej7SO1kRaMi1/nJOPACePAUcm4Q5OwZvPD4I903ajXWx9OZReLVjr4F+fmdFnk990Z7b9z/P548lJ+JDJgzEIPx2Groy2TxzSjnw37hWsdRjoGtTImJ6w");
            sb.Append("iE3vunKcMFrAJUPG916AMTkHwdzA7V6pY86Fe3MEZSPk2FCz+PQzNonlQ9/ePhh7bir5OXzISPYIeLF71Y2dx4T2jZAjQ15ZH2qTWI/Yse2zyP4IcIemkyHnc0fBJzuT");
            sb.Append("8GLP5s+Zp1XcgrqxI6VL2v5qr8zx5RB/MocvwmgeB4EMf6IPe+8dwMOfuRM7t/dIu1TeTNfN4afegQnyOaGsUCKAffcP4OmWOpAHu9M82GkK7gqsRh8fhnBW6Pt+WfBF");
            sb.Append("oeX+OHEPIiOn+3GfNSjzfxSShYJhWShTKG8NH/aifll/aj8OYCLvDMj8QmWLkF1HvEQCEAlAEVlYqPx3IPQ3gbTJdsZs15sAAAAASUVORK5CYII=");
            return sb.ToString();
        }
        /// <summary>
        /// Resetuje obrázek v paměti.
        /// Následující použití property ArrowVioletLeft32_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
        /// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
        /// </summary>
        public static void ArrowVioletLeft32_Reset()
        {
            _ArrowVioletLeft32 = null;
        }
        /// <summary>
        /// Úložiště objektu v paměti, při prvním použití ArrowVioletLeft32_Direct je objekt naplněn a následně využíván.
        /// </summary>
        private static System.Drawing.Image _ArrowVioletLeft32 = null;
        #endregion
        #region Image ArrowVioletRight16
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku arrow-violet-right-16.png.
        /// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
        /// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
        /// Případně je možno vyvolat metodu ArrowVioletRight16_Reset(), která zajistí regenerování obrázku z jeho definice.
        /// Bezpečnější je používání property ArrowVioletRight16, která vrací vždy nový objekt.
        /// Pro používání pro Button.Image, kde bude nastavováno Button.Enabled = false; je třeba použít property ArrowVioletRight16_FromFile.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\DavidPrac\VSProjects\ReportEditor\Reporting.Green\Pics\source\arrow-violet-right-16.png
        /// </remarks>
        public static System.Drawing.Image ArrowVioletRight16_Cached
        {
            get
            {
                if (_ArrowVioletRight16 == null) _ArrowVioletRight16 = ArrowVioletRight16;
                return _ArrowVioletRight16;
            }
        }
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku arrow-violet-right-16.png.
        /// Nelze používat jako Image pro Buttony, kde bude nastavováno Enabled = false (pak dojde k chybě .NET: Ot of memory).
        /// Pak je třeba použít Image ArrowVioletRight16_FromFile.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití ArrowVioletRight16_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property ArrowVioletRight16_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\DavidPrac\VSProjects\ReportEditor\Reporting.Green\Pics\source\arrow-violet-right-16.png
        /// </remarks>
        public static System.Drawing.Image ArrowVioletRight16 { get { return _ImageCreateFrom(_ArrowVioletRight16_string, null); } }
        /// <summary>
        /// Vrátí obrázek, načtený ze souboru arrow-violet-right-16.png.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití ArrowVioletRight16_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property ArrowVioletRight16_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\DavidPrac\VSProjects\ReportEditor\Reporting.Green\Pics\source\arrow-violet-right-16.png
        /// </remarks>
        public static System.Drawing.Image ArrowVioletRight16_FromFile { get { return _ImageCreateFrom(_ArrowVioletRight16_string, "arrow-violet-right-16.png"); } }
        /// <summary>
        /// Vygeneruje a vrátí string, který definuje obsah souboru ArrowVioletRight16
        /// </summary>
        /// <returns></returns>
        private static string _ArrowVioletRight16_string()
        {
            System.Text.StringBuilder sb = new System.Text.StringBuilder(832);
            sb.Append("iVBORw0KGgoAAAANSUhEUgAAAAgAAAAQCAYAAAArij59AAAABGdBTUEAAK/INwWK6QAAAAlwSFlzAAAOwgAADsIBFShKgAAAAA10RVh0U291cmNlAE51dm9sYaxPNfEA");
            sb.Append("AAAadEVYdFNvZnR3YXJlAFBhaW50Lk5FVCB2My41LjExR/NCNwAAAdFJREFUKFN9UU1IFGEYfk6VrfvtzJctCm1QSlEhpgUdOgUdOgTdlrCCMCPUXN3dcdkdddpmmm2c");
            sb.Append("mZ2xjoKuK7uD7cIiBpGB4CEIYjtEdPLSrcC74sHevvXSJTo8p+fvfXjRbDb/Cyhd498ypxM/JsOP+zNsAlokhzQbx8PQXTwK3QfMa/n9NXeN1LMTXxU22tMSqGwKQ8fj");
            sb.Append("GGy7DRi9+d3N+idqGA3KRSe/qJG0VJANPG0fQvzYLWA6ltmpJdfpw+JHCpJVmpbTW3lJZZZsYjh0D6JvbNjs0Q9qD9bpvbtFlScrpDGlYcnG0bS4CQpLQAmPZt3uOVq9");
            sb.Append("2aB32iYtDy6RHsmVfO4dwZQQZARUltK9LpeC3hq9TW3Q8p0S2bL5DLqkQXRC42rWjxV/r0SrFPTXqXSjTE6H9VIIZqFJ6sjrK/5BcPkNVc7XaKF7gSxZr/u82Ibn0kzc");
            sb.Append("O+fsBQOrVL0oyAuLZPPChsft0KyUBQr8xc/SmTJVRPfSpcPYz0VuRwXEwgRQPOHstsjyQIXck/Z3h8/F5rmHGeFOhEeAV6fm98tXA/I63W0R3ddyWtwUy5JIsTGREHW3");
            sb.Append("/U7vl8Ot68KNlsCQ82J+EtmIgn+++C+a+AN53uYzw4PW8QAAAABJRU5ErkJggg==");
            return sb.ToString();
        }
        /// <summary>
        /// Resetuje obrázek v paměti.
        /// Následující použití property ArrowVioletRight16_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
        /// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
        /// </summary>
        public static void ArrowVioletRight16_Reset()
        {
            _ArrowVioletRight16 = null;
        }
        /// <summary>
        /// Úložiště objektu v paměti, při prvním použití ArrowVioletRight16_Direct je objekt naplněn a následně využíván.
        /// </summary>
        private static System.Drawing.Image _ArrowVioletRight16 = null;
        #endregion
        #region Image ArrowVioletRight24
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku arrow-violet-right-24.png.
        /// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
        /// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
        /// Případně je možno vyvolat metodu ArrowVioletRight24_Reset(), která zajistí regenerování obrázku z jeho definice.
        /// Bezpečnější je používání property ArrowVioletRight24, která vrací vždy nový objekt.
        /// Pro používání pro Button.Image, kde bude nastavováno Button.Enabled = false; je třeba použít property ArrowVioletRight24_FromFile.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\DavidPrac\VSProjects\ReportEditor\Reporting.Green\Pics\source\arrow-violet-right-24.png
        /// </remarks>
        public static System.Drawing.Image ArrowVioletRight24_Cached
        {
            get
            {
                if (_ArrowVioletRight24 == null) _ArrowVioletRight24 = ArrowVioletRight24;
                return _ArrowVioletRight24;
            }
        }
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku arrow-violet-right-24.png.
        /// Nelze používat jako Image pro Buttony, kde bude nastavováno Enabled = false (pak dojde k chybě .NET: Ot of memory).
        /// Pak je třeba použít Image ArrowVioletRight24_FromFile.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití ArrowVioletRight24_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property ArrowVioletRight24_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\DavidPrac\VSProjects\ReportEditor\Reporting.Green\Pics\source\arrow-violet-right-24.png
        /// </remarks>
        public static System.Drawing.Image ArrowVioletRight24 { get { return _ImageCreateFrom(_ArrowVioletRight24_string, null); } }
        /// <summary>
        /// Vrátí obrázek, načtený ze souboru arrow-violet-right-24.png.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití ArrowVioletRight24_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property ArrowVioletRight24_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\DavidPrac\VSProjects\ReportEditor\Reporting.Green\Pics\source\arrow-violet-right-24.png
        /// </remarks>
        public static System.Drawing.Image ArrowVioletRight24_FromFile { get { return _ImageCreateFrom(_ArrowVioletRight24_string, "arrow-violet-right-24.png"); } }
        /// <summary>
        /// Vygeneruje a vrátí string, který definuje obsah souboru ArrowVioletRight24
        /// </summary>
        /// <returns></returns>
        private static string _ArrowVioletRight24_string()
        {
            System.Text.StringBuilder sb = new System.Text.StringBuilder(1268);
            sb.Append("iVBORw0KGgoAAAANSUhEUgAAAAwAAAAYCAYAAADOMhxqAAAABGdBTUEAAK/INwWK6QAAAAlwSFlzAAAOwgAADsIBFShKgAAAAA10RVh0U291cmNlAE51dm9sYaxPNfEA");
            sb.Append("AAAadEVYdFNvZnR3YXJlAFBhaW50Lk5FVCB2My41LjExR/NCNwAAAxpJREFUOE+tkl1Ik1EYx191CTp33I5zk6S1NLXU9KasIIoQCQzEi5JQKLOs1DltH9WWe7f26d5t");
            sb.Append("r7oy2fIj3ZfrS1wmlYGS3nkVdFMXQdFFdBF0YUigT2d7V1kEQfSHw3ng/H4PDw+H+qd0ofbkaaO6yf3XqIQaSpF1lt/OPylu55/idQlaky+/Zk+qnCuU6EKWKrdTe0Wm");
            sb.Append("mlbjzjoFv5mnQQrucUOKU6VcoRS0yg1FV+ZvtfjAvs+0rELtNSpBW6oOqTkgmZq00pREoRScKzAWX12cdjyEO1eja5Zy+rkWKfZqkDKFFuoTTDzVaTs5oRtdKDAW9izd");
            sb.Append("1cdgzr8AYWVozbzd8EiPVLsuS3oTTDw/BBXqyDPk6+7fbgyszxjn4LH7GYyfHlu1bDMGe5C20CyiKavIFB8pwVNqpORdEl6ss5dYXgePRyDW9QRmLU9htGFkxZpPD9JI");
            sb.Append("K7UJ6Y2CgiJbSdcJ1WeYYufb4JEITLfMQkw/C/5a32eb1GSxCOkch8jMCQeLgkRQUjqkEdBYp2YLPR8C+8Pw4FgMYuoZ8B0e+tgrsWqJgDgjGX22lqKzdUIzpu1emfdL");
            sb.Append("aGcE7h+dhqmOGNzcM/jGiW1HkyiXa2SFpmx9llVipL35/SsTW4IQLorCZO098O32vWewoz6JUpRZaCCwLsMmMZ2/XjnwLlAegKA8AoHSMAzJhz55JIyJwb0iDhYZKQPS");
            sb.Append("8CxiY4O3tO/VRFUQIiVRAkdgqMC34sl1saS7lAgJngh0Gpm7mt3qfjFWOQ7hHVEIlk+Cv2h4lZW4Jwi8xSGyUk2ZxznBIjJJHdg26ZP510LFkxCqiMJwyejXvjx2inQt");
            sb.Append("6y6ZpdyY+SlYReYCBjNLYzLSvfIOjJSNrRN43oWdVV7cn+IRDyS4Zn4j9zXsRPBI3Ivj5SEYrZhY924eWCadD7GYSfGQzt/TknmCE3qxTc5K2QV/6QjckN14SaB6MgIv");
            sb.Append("PsbGNGXUcYIT25Fb7KL7pOycR+xqdGNn+u9wPLXpVVzhwi6KjCBgsF1K4E1/guOpSz/AFfH9ugjkyXEltvEfQ1HfALklNYZ3KFSkAAAAAElFTkSuQmCC");
            return sb.ToString();
        }
        /// <summary>
        /// Resetuje obrázek v paměti.
        /// Následující použití property ArrowVioletRight24_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
        /// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
        /// </summary>
        public static void ArrowVioletRight24_Reset()
        {
            _ArrowVioletRight24 = null;
        }
        /// <summary>
        /// Úložiště objektu v paměti, při prvním použití ArrowVioletRight24_Direct je objekt naplněn a následně využíván.
        /// </summary>
        private static System.Drawing.Image _ArrowVioletRight24 = null;
        #endregion
        #region Image ArrowVioletRight32
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku arrow-violet-right-32.png.
        /// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
        /// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
        /// Případně je možno vyvolat metodu ArrowVioletRight32_Reset(), která zajistí regenerování obrázku z jeho definice.
        /// Bezpečnější je používání property ArrowVioletRight32, která vrací vždy nový objekt.
        /// Pro používání pro Button.Image, kde bude nastavováno Button.Enabled = false; je třeba použít property ArrowVioletRight32_FromFile.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\DavidPrac\VSProjects\ReportEditor\Reporting.Green\Pics\source\arrow-violet-right-32.png
        /// </remarks>
        public static System.Drawing.Image ArrowVioletRight32_Cached
        {
            get
            {
                if (_ArrowVioletRight32 == null) _ArrowVioletRight32 = ArrowVioletRight32;
                return _ArrowVioletRight32;
            }
        }
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku arrow-violet-right-32.png.
        /// Nelze používat jako Image pro Buttony, kde bude nastavováno Enabled = false (pak dojde k chybě .NET: Ot of memory).
        /// Pak je třeba použít Image ArrowVioletRight32_FromFile.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití ArrowVioletRight32_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property ArrowVioletRight32_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\DavidPrac\VSProjects\ReportEditor\Reporting.Green\Pics\source\arrow-violet-right-32.png
        /// </remarks>
        public static System.Drawing.Image ArrowVioletRight32 { get { return _ImageCreateFrom(_ArrowVioletRight32_string, null); } }
        /// <summary>
        /// Vrátí obrázek, načtený ze souboru arrow-violet-right-32.png.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití ArrowVioletRight32_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property ArrowVioletRight32_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\DavidPrac\VSProjects\ReportEditor\Reporting.Green\Pics\source\arrow-violet-right-32.png
        /// </remarks>
        public static System.Drawing.Image ArrowVioletRight32_FromFile { get { return _ImageCreateFrom(_ArrowVioletRight32_string, "arrow-violet-right-32.png"); } }
        /// <summary>
        /// Vygeneruje a vrátí string, který definuje obsah souboru ArrowVioletRight32
        /// </summary>
        /// <returns></returns>
        private static string _ArrowVioletRight32_string()
        {
            System.Text.StringBuilder sb = new System.Text.StringBuilder(1552);
            sb.Append("iVBORw0KGgoAAAANSUhEUgAAABAAAAAgCAYAAAAbifjMAAAABGdBTUEAAK/INwWK6QAAAAlwSFlzAAAOwgAADsIBFShKgAAAAA10RVh0U291cmNlAE51dm9sYaxPNfEA");
            sb.Append("AAAadEVYdFNvZnR3YXJlAFBhaW50Lk5FVCB2My41LjExR/NCNwAAA+5JREFUSEvNk19MW2UUwC/bBGV6e+9XwLUMnDxsKqIbYVMWZyKpMz4ZJ77MaDTZyJim69rRP7e0");
            sb.Append("9A+9pfe2txUmMKAEamlZKZTUAaGB6vTNJT75IG/TLHHJrBpj/B+Op+Mzjgw29rZf8uU2/c7vnO+c717m/kHPtjNn2NM3nwb2ffrvPUDlUlwq/L3DyOrpzhZBqSg6zrDt");
            sb.Append("eQN7+hQmKDWzBrq7BfTsqcMdGsO13tcVEOpM18+y7e+aVabtgspGI+6C/pG2l4Uac2Gufx4mLDGwagzfnWP1rRbevk1QmWnUHcBj64Rqc2G2ew4uT30B0RNDYKsyfoNt");
            sb.Append("6KzEWeIkHhq5CUZMYK+2FtL2TyA38DnkE5dhoPU82IjxK0HVcchU/jbj5pw0egOM7ActgsbyQ+psBhb8n0JO+QxyI8vQdzSyaufMSw6VdZ9TJdDoDcB+95g5w1KkOQwz");
            sb.Append("xnm41JGDRSkPix/lIPJCcNXJWaddnKPWs9kpBF4owX6P2Ihppe9wL8y0zUG2bQEWxTzMyfOgNAb+dHHCiId3qX0bzcOi6mA6iafEqjK1dqotVweaL0D6zSzMHL8EOX8e");
            sb.Append("Ms4syE+Iv3u4ThETsH4iUvMWbJjEwQkP4LWdcFU4CsMHRyB1NAPTr2VhwbcMadMMSHXiL918lxAgPQ9KJEDNW7CrrEwX5yjDoZ3zVrp+Gm6IQrJxCtKvzMJC9zJcbEuB");
            sb.Append("tNv/o5/3nsQEZVRbj4OzMm7esbOLs4s9VeJfY3tjkKibhKmWDMx7liDxVgLkRwMrEuk5QJX1ePguXO5SnLjgV/v+GK0dg7g2ARO1SUgfy0LyeApCGvkqJniOKv/j5d1M");
            sb.Append("N/HucHP29wKPi9ej+6MQ08YhXpuARH0KRuvHIaxVfkXZHCRSOdXW8PFeppv3bMPKx/xa77XxV8cg1Zhak59OwXjDxxDepfyGsqSQ0MOYgJoUQ/k7DMot4i7P19EXozB5");
            sb.Append("MIXHXpNjzyTgQ23kb5QHUCS3yV7ehX07n/VVuq8MHhhcJ8cbJ6GvpvcflGdR3H2bXAQTVOPKRGrDq3GsNvFY8mbP8aaL0L+nH2QSyKP41IZyEez9JT/x3YhqRtfkBpQP");
            sb.Append("paC/brAoXwkRqQn3afQG4AB1+GIUxmrwzlFOPJ+Gob3DEFRLKyjrzlf0l2xavYhIvDpZLRViT05AsnkaRupHIVQlf4vSGxF1uASnTiM3AY+nC1bKhVhTEkb3x0CpCt3A");
            sb.Append("yicVdXh7iMg06g4EiHgEE3x/Yd8QRDThn1E2KWqlTCEKjbgLeEUVMpFCIbX8JR7bjvLOLVX+jx6cMIoPYWWikGDpPclFit92ccqYAJfM4ODozv0Nw/wLvg3fvRszFHoA");
            sb.Append("AAAASUVORK5CYII=");
            return sb.ToString();
        }
        /// <summary>
        /// Resetuje obrázek v paměti.
        /// Následující použití property ArrowVioletRight32_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
        /// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
        /// </summary>
        public static void ArrowVioletRight32_Reset()
        {
            _ArrowVioletRight32 = null;
        }
        /// <summary>
        /// Úložiště objektu v paměti, při prvním použití ArrowVioletRight32_Direct je objekt naplněn a následně využíván.
        /// </summary>
        private static System.Drawing.Image _ArrowVioletRight32 = null;
        #endregion
        #region Image ArrowVioletUp16
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku arrow-violet-up-16.png.
        /// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
        /// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
        /// Případně je možno vyvolat metodu ArrowVioletUp16_Reset(), která zajistí regenerování obrázku z jeho definice.
        /// Bezpečnější je používání property ArrowVioletUp16, která vrací vždy nový objekt.
        /// Pro používání pro Button.Image, kde bude nastavováno Button.Enabled = false; je třeba použít property ArrowVioletUp16_FromFile.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\DavidPrac\VSProjects\ReportEditor\Reporting.Green\Pics\source\arrow-violet-up-16.png
        /// </remarks>
        public static System.Drawing.Image ArrowVioletUp16_Cached
        {
            get
            {
                if (_ArrowVioletUp16 == null) _ArrowVioletUp16 = ArrowVioletUp16;
                return _ArrowVioletUp16;
            }
        }
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku arrow-violet-up-16.png.
        /// Nelze používat jako Image pro Buttony, kde bude nastavováno Enabled = false (pak dojde k chybě .NET: Ot of memory).
        /// Pak je třeba použít Image ArrowVioletUp16_FromFile.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití ArrowVioletUp16_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property ArrowVioletUp16_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\DavidPrac\VSProjects\ReportEditor\Reporting.Green\Pics\source\arrow-violet-up-16.png
        /// </remarks>
        public static System.Drawing.Image ArrowVioletUp16 { get { return _ImageCreateFrom(_ArrowVioletUp16_string, null); } }
        /// <summary>
        /// Vrátí obrázek, načtený ze souboru arrow-violet-up-16.png.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití ArrowVioletUp16_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property ArrowVioletUp16_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\DavidPrac\VSProjects\ReportEditor\Reporting.Green\Pics\source\arrow-violet-up-16.png
        /// </remarks>
        public static System.Drawing.Image ArrowVioletUp16_FromFile { get { return _ImageCreateFrom(_ArrowVioletUp16_string, "arrow-violet-up-16.png"); } }
        /// <summary>
        /// Vygeneruje a vrátí string, který definuje obsah souboru ArrowVioletUp16
        /// </summary>
        /// <returns></returns>
        private static string _ArrowVioletUp16_string()
        {
            System.Text.StringBuilder sb = new System.Text.StringBuilder(836);
            sb.Append("iVBORw0KGgoAAAANSUhEUgAAABAAAAAICAYAAADwdn+XAAAABGdBTUEAAK/INwWK6QAAAAlwSFlzAAAOwgAADsIBFShKgAAAAA10RVh0U291cmNlAE51dm9sYaxPNfEA");
            sb.Append("AAAadEVYdFNvZnR3YXJlAFBhaW50Lk5FVCB2My41LjExR/NCNwAAAdVJREFUKFNjOHPmDEMCVwRDNKcfYyxXAGMKdxRDJk8iQxZPPEsOT1JOPl96SRlfAXspXyFDKV8B");
            sb.Append("QwlfPiOQz1gjUAHWCybiuMKAOIgBpDmXN4UhkyuGMYM7enKfe9f/fuu+/4W8GQsr+IrYaoGaqvjLGCr4i8A03IAMnniwrXm8aQy5PMmcGVxRiycF9/3fUrbr/zKztf97");
            sb.Append("FXr/l/HlrwPayt8kUMcAws2C9QgDwBp5UxmyeZLYs3kTts6In/Z/a9Pe/8v0V/9fJLb0/2LNVf8nq035XyNYfqBBoEawVbCRoUuoHWFALk8qQyZ3nGSuUNKheVlz/u+Y");
            sb.Append("cPD/Srf1/7sk2/93SXX8X6a38v9S3dX/p2nO/N8oVHMW6AKVTqE2hAFZPIlqhdKpJ5dVLf2/a/6R/6viNv3vUmn7X8qX11MmVNg80bT3/zLDFf+X6q/5P9tg3v92seaL");
            sb.Append("HYKthnADimWyr67rWvd/76aT/9eUbv3frt7yv4g3s7mSv4QBGOIM1QIlZX3qPX/mKS36v9Rg9f+Fpkv/94p134cbUCZVcLfbvv13l2nHjwbFmo8lfDlFQMwAMqCcr4ih");
            sb.Append("hr+UoVGgJqVLpP3tBJG+71PlpvyaINb35MyZMwwALN3fMSqN3lMAAAAASUVORK5CYII=");
            return sb.ToString();
        }
        /// <summary>
        /// Resetuje obrázek v paměti.
        /// Následující použití property ArrowVioletUp16_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
        /// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
        /// </summary>
        public static void ArrowVioletUp16_Reset()
        {
            _ArrowVioletUp16 = null;
        }
        /// <summary>
        /// Úložiště objektu v paměti, při prvním použití ArrowVioletUp16_Direct je objekt naplněn a následně využíván.
        /// </summary>
        private static System.Drawing.Image _ArrowVioletUp16 = null;
        #endregion
        #region Image ArrowVioletUp24
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku arrow-violet-up-24.png.
        /// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
        /// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
        /// Případně je možno vyvolat metodu ArrowVioletUp24_Reset(), která zajistí regenerování obrázku z jeho definice.
        /// Bezpečnější je používání property ArrowVioletUp24, která vrací vždy nový objekt.
        /// Pro používání pro Button.Image, kde bude nastavováno Button.Enabled = false; je třeba použít property ArrowVioletUp24_FromFile.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\DavidPrac\VSProjects\ReportEditor\Reporting.Green\Pics\source\arrow-violet-up-24.png
        /// </remarks>
        public static System.Drawing.Image ArrowVioletUp24_Cached
        {
            get
            {
                if (_ArrowVioletUp24 == null) _ArrowVioletUp24 = ArrowVioletUp24;
                return _ArrowVioletUp24;
            }
        }
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku arrow-violet-up-24.png.
        /// Nelze používat jako Image pro Buttony, kde bude nastavováno Enabled = false (pak dojde k chybě .NET: Ot of memory).
        /// Pak je třeba použít Image ArrowVioletUp24_FromFile.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití ArrowVioletUp24_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property ArrowVioletUp24_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\DavidPrac\VSProjects\ReportEditor\Reporting.Green\Pics\source\arrow-violet-up-24.png
        /// </remarks>
        public static System.Drawing.Image ArrowVioletUp24 { get { return _ImageCreateFrom(_ArrowVioletUp24_string, null); } }
        /// <summary>
        /// Vrátí obrázek, načtený ze souboru arrow-violet-up-24.png.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití ArrowVioletUp24_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property ArrowVioletUp24_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\DavidPrac\VSProjects\ReportEditor\Reporting.Green\Pics\source\arrow-violet-up-24.png
        /// </remarks>
        public static System.Drawing.Image ArrowVioletUp24_FromFile { get { return _ImageCreateFrom(_ArrowVioletUp24_string, "arrow-violet-up-24.png"); } }
        /// <summary>
        /// Vygeneruje a vrátí string, který definuje obsah souboru ArrowVioletUp24
        /// </summary>
        /// <returns></returns>
        private static string _ArrowVioletUp24_string()
        {
            System.Text.StringBuilder sb = new System.Text.StringBuilder(1336);
            sb.Append("iVBORw0KGgoAAAANSUhEUgAAABgAAAAMCAYAAAB4MH11AAAABGdBTUEAAK/INwWK6QAAAAlwSFlzAAAOwgAADsIBFShKgAAAAA10RVh0U291cmNlAE51dm9sYaxPNfEA");
            sb.Append("AAAadEVYdFNvZnR3YXJlAFBhaW50Lk5FVCB2My41LjExR/NCNwAAA01JREFUOE+Nk11oW2UYx58YFzDN+ezajtp17KOtjSwOLyZMhjBU0AulDmbNRTuSLc3SNuk5bU7a");
            sb.Append("s+azyWmSNacfSJkt2+hJe9YWnJvWjBX0ZjgKu96FXu1CUMYYTFAcbDw+iUdahal/+PPePOf3f97nPC/8pR7nydrZ5XjDftLxpv2U4y37x44TtoCrBwaZAISZgJN8PMIE");
            sb.Append("T0hsiBlhw0AnDLH9tjDTZx9ignaJHHB+BCoXrbH+Jj/TC6ed3eRT4KvrBn+dF/pcp6tgCjjDSWIolPHE7+U8mR8UUVaG2cF6lY9CjJUhxlU9XAOP86OQ4M9b1H8RdQb9");
            sb.Append("rl4I1fUKBB/LH8v+uBZaR+N9E/N7tQejgpxV2KGmFDcGyf8D3KkwOwBBpxcGXL4WuXGgUHq7+Ohz+Qu81vUlmh3reKXTwNK+qV/i4ti8yimHxugWE0LS+vo/NMichQCN");
            sb.Append("ZoDxtSt7IxfnPpx+fEP9Cq9/soHlThOXXi6jeWAVjVdXcO7A3K+ZhuRyglc9SU615YSMRXmO+l0+8Du7bDQWT2yftHbRO//bRu4mXvdX0Dhmot5aelJqvvC7QTcwX1lD");
            sb.Append("47CJn7bPP9EaJ77O8PGjaT7+wqSQtWj/UBXe5/TaqfPjavvw5uXgpaeV0iZuyJtYfu8qXjhUeKgK0enxhlh+5kjpZ+Poci2k7FnFhc7FZ8U9hduakHk3J6R3FcW8Rd0h");
            sb.Append("CrBHuOA7qdfV2ytK+enmZ99iJf0Nmt3rWOzI/6SK0bjCSg0qKwvpPeelGbd+f+k1A1c6VnHlyDouHr78bKZl+m5RnOyigF1/Unco5Oqpj7XK1xb9C7ih01hSFVzuvYoF");
            sb.Append("t3Y/xsthgvPVlVRpHROc4srsTvj0/aXvF1oXcWl/GQ2PiQvuSzjdpN8qilqjhd0W7Toz0hhJpt3x72jXt3Luia1ka7xCcG+UDb+ksBGrEiDOKZDiVUdWTH1QrJ+8oe+e");
            sb.Append("2pptmt2aa569ozfo+SmxyFml2xqhzuhl8kNM30GJDbbJbKiNwC2jnOygfafOFasSIC0kICWMA838RU2caJ4Uc20FQWuj0RwkuKjX6zardFvDrFR7+hJ7DggOI+wgVMGj");
            sb.Append("FPw8aWIWCE7WoECu/lwKAAqwKgD+AGibP8A1KRfVAAAAAElFTkSuQmCC");
            return sb.ToString();
        }
        /// <summary>
        /// Resetuje obrázek v paměti.
        /// Následující použití property ArrowVioletUp24_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
        /// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
        /// </summary>
        public static void ArrowVioletUp24_Reset()
        {
            _ArrowVioletUp24 = null;
        }
        /// <summary>
        /// Úložiště objektu v paměti, při prvním použití ArrowVioletUp24_Direct je objekt naplněn a následně využíván.
        /// </summary>
        private static System.Drawing.Image _ArrowVioletUp24 = null;
        #endregion
        #region Image ArrowVioletUp32
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku arrow-violet-up-32.png.
        /// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
        /// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
        /// Případně je možno vyvolat metodu ArrowVioletUp32_Reset(), která zajistí regenerování obrázku z jeho definice.
        /// Bezpečnější je používání property ArrowVioletUp32, která vrací vždy nový objekt.
        /// Pro používání pro Button.Image, kde bude nastavováno Button.Enabled = false; je třeba použít property ArrowVioletUp32_FromFile.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\DavidPrac\VSProjects\ReportEditor\Reporting.Green\Pics\source\arrow-violet-up-32.png
        /// </remarks>
        public static System.Drawing.Image ArrowVioletUp32_Cached
        {
            get
            {
                if (_ArrowVioletUp32 == null) _ArrowVioletUp32 = ArrowVioletUp32;
                return _ArrowVioletUp32;
            }
        }
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku arrow-violet-up-32.png.
        /// Nelze používat jako Image pro Buttony, kde bude nastavováno Enabled = false (pak dojde k chybě .NET: Ot of memory).
        /// Pak je třeba použít Image ArrowVioletUp32_FromFile.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití ArrowVioletUp32_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property ArrowVioletUp32_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\DavidPrac\VSProjects\ReportEditor\Reporting.Green\Pics\source\arrow-violet-up-32.png
        /// </remarks>
        public static System.Drawing.Image ArrowVioletUp32 { get { return _ImageCreateFrom(_ArrowVioletUp32_string, null); } }
        /// <summary>
        /// Vrátí obrázek, načtený ze souboru arrow-violet-up-32.png.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití ArrowVioletUp32_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property ArrowVioletUp32_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\DavidPrac\VSProjects\ReportEditor\Reporting.Green\Pics\source\arrow-violet-up-32.png
        /// </remarks>
        public static System.Drawing.Image ArrowVioletUp32_FromFile { get { return _ImageCreateFrom(_ArrowVioletUp32_string, "arrow-violet-up-32.png"); } }
        /// <summary>
        /// Vygeneruje a vrátí string, který definuje obsah souboru ArrowVioletUp32
        /// </summary>
        /// <returns></returns>
        private static string _ArrowVioletUp32_string()
        {
            System.Text.StringBuilder sb = new System.Text.StringBuilder(1684);
            sb.Append("iVBORw0KGgoAAAANSUhEUgAAACAAAAAQCAYAAAB3AH1ZAAAABGdBTUEAAK/INwWK6QAAAAlwSFlzAAAOwgAADsIBFShKgAAAAA10RVh0U291cmNlAE51dm9sYaxPNfEA");
            sb.Append("AAAadEVYdFNvZnR3YXJlAFBhaW50Lk5FVCB2My41LjExR/NCNwAABFFJREFUSEvNlV9MU1ccx49jLMyW096LVKcTBDPYFM22DGd8cGZ/4pjZdEvmiJluohaL9EJLbyml");
            sb.Append("Le2FlrbQlnXo4EoBayl/1yEKagmw+bBkWcye9rDsiT3sQbLMNSZbottvv1suySIScdnDvsk3vUnPuZ/v+d1zfofcr+OKI+jytCvw+aTiKNEqj5HK7AqiQ0uqpWeIkeoz");
            sb.Append("aqiuwECrnjFSLpOnhvR/1cqTxEyNader6ogFbVXxaDOxqS3pMQ+VBD6hPEpOIVir/IhUKj9OW1Iarqp9nMuuLDcyZ76uY7mbRlp9GoFZElBSGo5ehJsX4apVwleSkdYg");
            sb.Append("vApdvZbL1lbWafQ/n30nDOJBEawa868myjVgANqgMhGH2irP+g8lwQ1Ur0C4hX+KW4gc64EpzzQkyi/D2WfPQWNOfQpX7sXV5qy61KtRDYIRKpVeg79+6xbTnajuAiR9");
            sb.Append("s/D5gUsQLxyC+I4R6HpOBKfG/gdWoAfLXSBVwal2yG/5l6qlHMJPEY6e3oTwSGOx6ffh+mFIts9C4u0JGCgchIGNcRjIH4T4zhHo2dEHLRuEu1iBcQxQJGAINyvIb3tE");
            sb.Append("SSvXKysk+HaEjwql9nvj7nGEz0Hi/csw9OIY9BdFoXdzH8QwRCwvjiFGoe/5KPg3+/5yqBtnXIx9t3Z78tFDGKSV5zYRfba2lKOVM549rj+vhCYhGZyDLz6chOHXE3B+");
            sb.Append("ZwQEjeOeM8d2V9wmwmDJsFyJUYi+FIdgXhAExnFTYJpec7Oex7ysR377QySt3Kjm1yB8f41a+13gLR9cE5Np+CXtVRg7PAHi7h5waKx3LCrjp/jNW5sLHbcvHOjHqoxA");
            sb.Append("XA5xcdcQhAvD4GZdP7oZ4bCP9Wb4Wa9MWUF4xCRnYDN515Cr+6Hzgw6Yjs7CdPgruMInMcAUdO8Vwa5pSOE5b8Ydr7arGxSNlK9ryXfd6t3XC4MvjEBsy+KeGHh5BM4V");
            sb.Append("fwbedZ6fPEzLcT/ry2pn/TLtAZLg+M2P8Ju4+UiVCF+O3YCZ7htw1T0LE/w16NrXBdYc8wLCTVZV/dql7oa7/QmHqqGieUPTfFdpN8RKcHMW4OnAEPE9YyCWRKBd47+F");
            sb.Append("AfQYIFPGLRdHdSr0zCeHgnC9NwlTHdMw4b4OCeskdL7SCdZ1pnmEn0Dwk1LDWZIdu5zAODNdatt7bo3wfbggDL0b+yGaH4OLGCa2axi6i0VoY33fBFg/I09bLmw2WXje");
            sb.Append("2615/EJTkS3l3OpIudDOfPtvFsb4LcIP2tW2DGnl98vFOIg/t2NNM+Pc62GEOfzetwM5balgbiAVWh9MdawP/RJg23qCbLtCnrJcWH7pktHgBfOqgerKsMeXmai+jKfc");
            sb.Append("m9hmtyH4gfAlIZwE2QDxsC1bW1n3/lbWU+ZDY5gyLP0bGODpMBuSR68gDICuThv7O+HxDjDT2vTF8s+yryTpzGMAggGIdPT8bCvaS6TNhwFIiA3KI/8XIuRvXHD3uC4x");
            sb.Append("mFsAAAAASUVORK5CYII=");
            return sb.ToString();
        }
        /// <summary>
        /// Resetuje obrázek v paměti.
        /// Následující použití property ArrowVioletUp32_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
        /// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
        /// </summary>
        public static void ArrowVioletUp32_Reset()
        {
            _ArrowVioletUp32 = null;
        }
        /// <summary>
        /// Úložiště objektu v paměti, při prvním použití ArrowVioletUp32_Direct je objekt naplněn a následně využíván.
        /// </summary>
        private static System.Drawing.Image _ArrowVioletUp32 = null;
        #endregion
        #region Společné metody pro konverzi
        /// <summary>
        /// Vrátí Image z definice (string). Image generuje buď v paměti, anebo s pomocí souboru.
        /// Pokud není zadán parametr (cacheFileName) (když je null), generuje se Image v paměti.
        /// Pokud je soubor (cacheFileName) definován, pak se Image čte z něj.
        /// Pokud soubor neexistuje, nejprve se vytvoří.
        /// Umístění souboru (adresář) je dán property _ImageCacheDir, defaultně je to adresář (Sys:\Documents and Settings\All Users\Data aplikací\IconCache).
        /// Obsah obrázku definuje metoda getDataMethod.
        /// </summary>
        /// <param name="getDataMethod"></param>
        /// <param name="cacheFileName"></param>
        /// <returns></returns>
        private static System.Drawing.Image _ImageCreateFrom(_GetStringDelegate getDataMethod, string cacheFileName)
        {
            System.Drawing.Image image;
            if (cacheFileName == null)
            {
                using (System.IO.MemoryStream ms = new System.IO.MemoryStream(Convert.FromBase64String(getDataMethod())))
                {
                    image = System.Drawing.Image.FromStream(ms);
                }
                return image;
            }
            string fileName = System.IO.Path.Combine(_ImageCacheDir, cacheFileName);
            if (!System.IO.File.Exists(fileName))
                System.IO.File.WriteAllBytes(fileName, Convert.FromBase64String(getDataMethod()));
            if (System.IO.File.Exists(fileName))
                return Image.FromFile(fileName);
            return null;
        }
        /// <summary>
        /// Obsahuje jméno adresáře, který slouží jako Cache pro obrázky systému.
        /// </summary>
        private static string _ImageCacheDir
        {
            get
            {
                if (__ImageCacheDir == null)
                    __ImageCacheDir = Asol.Reporting.Support.Assistant.GetPath(Support.Assistant.PathType.ApplicationCache, @"Commands");
                return __ImageCacheDir;
            }
        } private static string __ImageCacheDir;
        /// <summary>
        /// Předpis pro metody, které generují obsah souboru s daty
        /// </summary>
        /// <returns></returns>
        private delegate string _GetStringDelegate();
        /// <summary>
        /// Vrátí Icon z dat (string), která jsou předána na vstup v kódování Base64
        /// </summary>
        /// <param name="data">Vstupní data v kódování Base64</param>
        /// <returns>Icon vytvořená z dat</returns>
        public static System.Drawing.Icon ConvertStringToIcon(string data)
        {
            System.Drawing.Icon icon;
            using (System.IO.MemoryStream ms = new System.IO.MemoryStream(Convert.FromBase64String(data)))
            {
                icon = new System.Drawing.Icon(ms);
            }
            return icon;
        }
        /// <summary>
        /// Vrátí Cursor z dat (string), která jsou předána na vstup v kódování Base64
        /// </summary>
        /// <param name="data">Vstupní data v kódování Base64</param>
        /// <returns>Cursor vytvořený z dat</returns>
        public static System.Windows.Forms.Cursor ConvertStringToCursor(string data)
        {
            System.Windows.Forms.Cursor cursor;
            using (System.IO.MemoryStream ms = new System.IO.MemoryStream(Convert.FromBase64String(data)))
            {
                cursor = new System.Windows.Forms.Cursor(ms);
            }
            return cursor;
        }
        #endregion
    }
    #endregion
}
